use nanosleep() instead of usleep()

POSIX.1-2001 declares usleep() function obsolete and POSIX.1-2008
removes it.

[Kay Sievers]
  - include time.h
  - use const for timespec
  - scsi_id: drop rand() in retry loop
  - modem-probe: rename msuspend() to msleep()

diff --git a/extras/modem-modeswitch/ma8280p_us.c b/extras/modem-modeswitch/ma8280p_us.c
index 13d11160e1b41024c7f215c26a8824bbce102a5c..3cf9eb9eb28388434cb275a47ef9b7eeaa2d779e 100644 (file)
--- a/extras/modem-modeswitch/ma8280p_us.c
+++ b/extras/modem-modeswitch/ma8280p_us.c
@@ -87,11 +87,19 @@
 #include <assert.h>
 #include <signal.h>
 #include <ctype.h>
+#include <time.h>
 #include <usb.h>
 
 #include "utils.h"
 #include "ma8280p_us.h"
 
+static void msleep(long msec)
+{
+       struct timespec duration = { 0, msec * 1000 * 1000 };
+
+       nanosleep(&duration, NULL);
+}
+
 int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
 {
        int ret = 1;
@@ -104,11 +112,11 @@ int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
        }
 
        ret = usb_get_descriptor(devh, 0x0000001, 0x0000000, buf, 0x0000012);
-       usleep(6*1000);
+       msleep(6);
        ret = usb_get_descriptor(devh, 0x0000001, 0x0000000, buf, 0x0000012);
-       usleep(6*1000);
+       msleep(6);
        ret = usb_get_descriptor(devh, 0x0000002, 0x0000000, buf, 0x0000400);
-       usleep(10*1000);
+       msleep(10);
        ret = usb_release_interface(devh, 0);
        if (ret != 0) 
                debug ("%s: failed to release interface before set_configuration: %d", dev->filename, ret);
@@ -117,335 +125,335 @@ int ma8280p_switch (struct usb_dev_handle *devh, struct usb_device *dev)
        if (ret != 0) 
                debug ("%s: claim after set_configuration failed with error %d", dev->filename, ret);
        //ret = usb_set_altinterface(devh, 0);
-       //usleep(33*1000);
+       //msleep(33);
        ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE + USB_ENDPOINT_IN, 0x0000001, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
-       usleep(5*1000);
+       msleep(5);
        memcpy(buf, "\xb0\x04\x00\x00\x02\x90\x26\x86", 0x0000008);
        ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 0x0000009, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
-       usleep(4*1000);
+       msleep(4);
        memcpy(buf, "\xb0\x04\x00\x00\x02\x90\x26\x86", 0x0000008);
        ret = usb_control_msg(devh, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 0x0000009, 0x0000300, 0x0000000, buf, 0x0000008, 1000);
-       usleep(4*1000);
+       msleep(4);
 
-       usleep(4*1000);
+       msleep(4);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(6*1000);
+       msleep(6);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        //URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
-       usleep(4*1000);
+       msleep(4);
        memcpy(buf, "\x37\x01\xfe\xdb\xc1\x33\x1f\x83", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(3*1000);
+       msleep(3);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        memcpy(buf, "\x37\x0e\xb5\x9d\x3b\x8a\x91\x51", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(7*1000);
+       msleep(7);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        memcpy(buf, "\x34\x87\xba\x0d\xfc\x8a\x91\x51", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(7*1000);
+       msleep(7);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(2*1000);
+       msleep(2);
        //URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
-       usleep(4*1000);
+       msleep(4);
        memcpy(buf, "\x37\x01\xfe\xdb\xc1\x33\x1f\x83", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(2*1000);
+       msleep(2);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        memcpy(buf, "\x37\x0e\xb5\x9d\x3b\x8a\x91\x51", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(7*1000);
+       msleep(7);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        memcpy(buf, "\x34\x87\xba\x0d\xfc\x8a\x91\x51", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(7*1000);
+       msleep(7);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(8*1000);
+       msleep(8);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        //URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
-       usleep(4*1000);
+       msleep(4);
        memcpy(buf, "\x33\x04\xfe\x00\xf4\x6c\x1f\xf0", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(3*1000);
+       msleep(3);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
-       usleep(1*1000);
+       msleep(1);
        //URB_FUNCTION_GET_STATUS_FROM_ENDPOINT skipped
-       usleep(4*1000);
+       msleep(4);
        memcpy(buf, "\x32\x07\xfe\xf0\x29\xb9\x3a\xf0", 0x0000008);
        ret = usb_interrupt_write(devh, 0x00000002, buf, 0x0000008, 1000);
-       usleep(3*1000);
+       msleep(3);
        ret = usb_interrupt_read(devh, 0x00000081, buf, 0x0000008, 1000);
 
        if (buf)

diff --git a/extras/scsi_id/scsi_serial.c b/extras/scsi_id/scsi_serial.c
index 0f883dc02f19b7c86d14e2611e3f885600d4f922..2e9168f9419de2b3c53e880142c4d907d4c5f37d 100644 (file)
--- a/extras/scsi_id/scsi_serial.c
+++ b/extras/scsi_id/scsi_serial.c
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <syslog.h>
+#include <time.h>
 #include <inttypes.h>
 #include <scsi/scsi.h>
 #include <scsi/sg.h>
@@ -846,13 +847,15 @@ int scsi_get_serial(struct udev *udev,
        memset(dev_scsi->serial, 0, len);
        dbg(udev, "opening %s\n", devname);
        while (--cnt) {
+               const struct timespec duration = { 0, 500 * 1000 * 1000 };
+
                fd = open(devname, O_RDONLY | O_NONBLOCK);
                if (fd >= 0)
                        break;
                info(udev, "%s: cannot open %s: %s\n", dev_scsi->kernel, devname, strerror(errno));
                if (errno != EBUSY)
                        break;
-               usleep(500000 + (rand() % 100000) );
+               nanosleep(&duration, NULL);
        }
        if (fd < 0)
                return 1;

diff --git a/udev/udev-event.c b/udev/udev-event.c
index 3a6c71abe904efeeacb40f3a464dce4edd4e75aa..8183793e5f4536824b3fd62fc0b0f207daf0a275 100644 (file)
--- a/udev/udev-event.c
+++ b/udev/udev-event.c
@@ -23,9 +23,10 @@
 #include <errno.h>
 #include <ctype.h>
 #include <string.h>
+#include <time.h>
+#include <net/if.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <net/if.h>
 #include <linux/sockios.h>
 
 #include "udev.h"
@@ -505,6 +506,8 @@ static int rename_netif(struct udev_event *event)
                util_strscpy(ifr.ifr_newname, IFNAMSIZ, event->name);
                loop = 90 * 20;
                while (loop--) {
+                       const struct timespec duration = { 0, 1000 * 1000 * 1000 / 20 };
+
                        err = ioctl(sk, SIOCSIFNAME, &ifr);
                        if (err == 0) {
                                rename_netif_kernel_log(ifr);
@@ -518,7 +521,7 @@ static int rename_netif(struct udev_event *event)
                        }
                        dbg(event->udev, "wait for netif '%s' to become free, loop=%i\n",
                            event->name, (90 * 20) - loop);
-                       usleep(1000 * 1000 / 20);
+                       nanosleep(&duration, NULL);
                }
        }
 exit:

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index eeb71bc87b9d6eb0906b671bb7ab81f64495d79e..a45a8138f52cdb2702fa9f0a9020db9f8b9ad7aa 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -27,6 +27,7 @@
 #include <errno.h>
 #include <dirent.h>
 #include <fnmatch.h>
+#include <time.h>
 
 #include "udev.h"
 
@@ -814,6 +815,8 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
 
        dbg(udev, "will wait %i sec for '%s'\n", timeout, file);
        while (--loop) {
+               const struct timespec duration = { 0, 1000 * 1000 * 1000 / WAIT_LOOP_PER_SECOND };
+
                /* lookup file */
                if (stat(file, &stats) == 0) {
                        info(udev, "file '%s' appeared after %i loops\n", file, (timeout * WAIT_LOOP_PER_SECOND) - loop-1);
@@ -825,7 +828,7 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
                        return -2;
                }
                info(udev, "wait for '%s' for %i mseconds\n", file, 1000 / WAIT_LOOP_PER_SECOND);
-               usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+               nanosleep(&duration, NULL);
        }
        info(udev, "waiting for '%s' failed\n", file);
        return -1;

diff --git a/udev/udevadm-settle.c b/udev/udevadm-settle.c
index 682819201e46fc2f970626246c25b2608b7d1cec..124c59698c491ab04e9b9ecd2722738ad544286d 100644 (file)
--- a/udev/udevadm-settle.c
+++ b/udev/udevadm-settle.c
@@ -28,6 +28,7 @@
 #include <syslog.h>
 #include <getopt.h>
 #include <signal.h>
+#include <time.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ -180,6 +181,7 @@ int udevadm_settle(struct udev *udev, int argc, char *argv[])
 
        while (1) {
                struct stat statbuf;
+               const struct timespec duration = { 0 , 1000 * 1000 * 1000 / LOOP_PER_SECOND };
 
                if (exists != NULL && stat(exists, &statbuf) == 0) {
                        rc = 0;
@@ -203,7 +205,7 @@ int udevadm_settle(struct udev *udev, int argc, char *argv[])
                if (is_timeout)
                        break;
 
-               usleep(1000 * 1000 / LOOP_PER_SECOND);
+               nanosleep(&duration, NULL);
        }
 
        /* if we reached the timeout, print the list of remaining events */