9 files changed, 87 insertions, 136 deletions

diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 932d6b1c9d0b..45f47c1c0a35 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -3657,7 +3657,7 @@ void mpi_receive_802_11 (struct airo_info *ai)
         ptr += hdrlen;
         if (hdrlen == 24)
                 ptr += 6;
-        gap = le16_to_cpu(get_unaligned((__le16 *)ptr));
+        gap = get_unaligned_le16(ptr);
         ptr += sizeof(__le16);
         if (gap) {
                 if (gap <= 8)
@@ -4347,24 +4347,28 @@ static int proc_config_open( struct inode *inode, struct file *file );
 static int proc_wepkey_open( struct inode *inode, struct file *file );
 
 static const struct file_operations proc_statsdelta_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .open           = proc_statsdelta_open,
         .release        = proc_close
 };
 
 static const struct file_operations proc_stats_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .open           = proc_stats_open,
         .release        = proc_close
 };
 
 static const struct file_operations proc_status_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .open           = proc_status_open,
         .release        = proc_close
 };
 
 static const struct file_operations proc_SSID_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_SSID_open,
@@ -4372,6 +4376,7 @@ static const struct file_operations proc_SSID_ops = {
 };
 
 static const struct file_operations proc_BSSList_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_BSSList_open,
@@ -4379,6 +4384,7 @@ static const struct file_operations proc_BSSList_ops = {
 };
 
 static const struct file_operations proc_APList_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_APList_open,
@@ -4386,6 +4392,7 @@ static const struct file_operations proc_APList_ops = {
 };
 
 static const struct file_operations proc_config_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_config_open,
@@ -4393,6 +4400,7 @@ static const struct file_operations proc_config_ops = {
 };
 
 static const struct file_operations proc_wepkey_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_wepkey_open,
@@ -4411,10 +4419,6 @@ struct proc_data {
         void (*on_close) (struct inode *, struct file *);
 };
 
-#ifndef SETPROC_OPS
-#define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
-#endif
-
 static int setup_proc_entry( struct net_device *dev,
                              struct airo_info *apriv ) {
         struct proc_dir_entry *entry;
@@ -4430,100 +4434,76 @@ static int setup_proc_entry( struct net_device *dev,
         apriv->proc_entry->owner = THIS_MODULE;
 
         /* Setup the StatsDelta */
-        entry = create_proc_entry("StatsDelta",
-                                  S_IFREG | (S_IRUGO&proc_perm),
-                                  apriv->proc_entry);
+        entry = proc_create_data("StatsDelta",
+                                 S_IFREG | (S_IRUGO&proc_perm),
+                                 apriv->proc_entry, &proc_statsdelta_ops, dev);
         if (!entry)
                 goto fail_stats_delta;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_statsdelta_ops);
 
         /* Setup the Stats */
-        entry = create_proc_entry("Stats",
-                                  S_IFREG | (S_IRUGO&proc_perm),
-                                  apriv->proc_entry);
+        entry = proc_create_data("Stats",
+                                 S_IFREG | (S_IRUGO&proc_perm),
+                                 apriv->proc_entry, &proc_stats_ops, dev);
         if (!entry)
                 goto fail_stats;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_stats_ops);
 
         /* Setup the Status */
-        entry = create_proc_entry("Status",
-                                  S_IFREG | (S_IRUGO&proc_perm),
-                                  apriv->proc_entry);
+        entry = proc_create_data("Status",
+                                 S_IFREG | (S_IRUGO&proc_perm),
+                                 apriv->proc_entry, &proc_status_ops, dev);
         if (!entry)
                 goto fail_status;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_status_ops);
 
         /* Setup the Config */
-        entry = create_proc_entry("Config",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("Config",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_config_ops, dev);
         if (!entry)
                 goto fail_config;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_config_ops);
 
         /* Setup the SSID */
-        entry = create_proc_entry("SSID",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("SSID",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_SSID_ops, dev);
         if (!entry)
                 goto fail_ssid;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_SSID_ops);
 
         /* Setup the APList */
-        entry = create_proc_entry("APList",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("APList",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_APList_ops, dev);
         if (!entry)
                 goto fail_aplist;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_APList_ops);
 
         /* Setup the BSSList */
-        entry = create_proc_entry("BSSList",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("BSSList",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_BSSList_ops, dev);
         if (!entry)
                 goto fail_bsslist;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_BSSList_ops);
 
         /* Setup the WepKey */
-        entry = create_proc_entry("WepKey",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("WepKey",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_wepkey_ops, dev);
         if (!entry)
                 goto fail_wepkey;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_wepkey_ops);
 
         return 0;
 
@@ -5625,9 +5605,9 @@ static int __init airo_init_module( void )
         int have_isa_dev = 0;
 #endif
 
-        airo_entry = create_proc_entry("aironet",
+        airo_entry = create_proc_entry("driver/aironet",
                                        S_IFDIR | airo_perm,
-                                       proc_root_driver);
+                                       NULL);
 
         if (airo_entry) {
                 airo_entry->uid = proc_uid;
@@ -5651,7 +5631,7 @@ static int __init airo_init_module( void )
         airo_print_info("", "Finished probing for PCI adapters");
 
         if (i) {
-                remove_proc_entry("aironet", proc_root_driver);
+                remove_proc_entry("driver/aironet", NULL);
                 return i;
         }
 #endif
@@ -5673,7 +5653,7 @@ static void __exit airo_cleanup_module( void )
 #ifdef CONFIG_PCI
         pci_unregister_driver(&airo_driver);
 #endif
-        remove_proc_entry("aironet", proc_root_driver);
+        remove_proc_entry("driver/aironet", NULL);
 }
 
 /*
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index e18305b781c9..4e5c8fc35200 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -58,10 +58,6 @@
 #include "reg.h"
 #include "debug.h"
 
-/* unaligned little endian access */
-#define LE_READ_2(_p) (le16_to_cpu(get_unaligned((__le16 *)(_p))))
-#define LE_READ_4(_p) (le32_to_cpu(get_unaligned((__le32 *)(_p))))
-
 enum {
         ATH_LED_TX,
         ATH_LED_RX,
@@ -2909,9 +2905,9 @@ static void ath5k_configure_filter(struct ieee80211_hw *hw,
                         if (!mclist)
                                 break;
                         /* calculate XOR of eight 6-bit values */
-                        val = LE_READ_4(mclist->dmi_addr + 0);
+                        val = get_unaligned_le32(mclist->dmi_addr + 0);
                         pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
-                        val = LE_READ_4(mclist->dmi_addr + 3);
+                        val = get_unaligned_le32(mclist->dmi_addr + 3);
                         pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
                         pos &= 0x3f;
                         mfilt[pos / 32] |= (1 << (pos % 32));
diff --git a/drivers/net/wireless/b43/leds.c b/drivers/net/wireless/b43/leds.c
index 0aac1ff511df..36a9c42df835 100644
--- a/drivers/net/wireless/b43/leds.c
+++ b/drivers/net/wireless/b43/leds.c
@@ -116,10 +116,7 @@ static void b43_unregister_led(struct b43_led *led)
 {
         if (!led->dev)
                 return;
-        if (led->dev->suspend_in_progress)
-                led_classdev_unregister_suspended(&led->led_dev);
-        else
-                led_classdev_unregister(&led->led_dev);
+        led_classdev_unregister(&led->led_dev);
         b43_led_turn_off(led->dev, led->index, led->activelow);
         led->dev = NULL;
 }
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 1e95c4f5256b..6c7db9a1a466 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2171,7 +2171,7 @@ static int b43_write_initvals(struct b43_wldev *dev,
                                 goto err_format;
                         array_size -= sizeof(iv->data.d32);
 
-                        value = be32_to_cpu(get_unaligned(&iv->data.d32));
+                        value = get_unaligned_be32(&iv->data.d32);
                         b43_write32(dev, offset, value);
 
                         iv = (const struct b43_iv *)((const uint8_t *)iv +
@@ -2808,10 +2808,10 @@ static int b43_rng_read(struct hwrng *rng, u32 * data)
         return (sizeof(u16));
 }
 
-static void b43_rng_exit(struct b43_wl *wl, bool suspended)
+static void b43_rng_exit(struct b43_wl *wl)
 {
         if (wl->rng_initialized)
-                __hwrng_unregister(&wl->rng, suspended);
+                hwrng_unregister(&wl->rng);
 }
 
 static int b43_rng_init(struct b43_wl *wl)
@@ -3832,7 +3832,7 @@ static void b43_wireless_core_exit(struct b43_wldev *dev)
 
         if (!dev->suspend_in_progress) {
                 b43_leds_exit(dev);
-                b43_rng_exit(dev->wl, false);
+                b43_rng_exit(dev->wl);
         }
         b43_dma_free(dev);
         b43_pio_free(dev);
@@ -4621,7 +4621,7 @@ static int b43_resume(struct ssb_device *dev)
                 err = b43_wireless_core_start(wldev);
                 if (err) {
                         b43_leds_exit(wldev);
-                        b43_rng_exit(wldev->wl, true);
+                        b43_rng_exit(wldev->wl);
                         b43_wireless_core_exit(wldev);
                         b43err(wl, "Resume failed at core start\n");
                         goto out;
diff --git a/drivers/net/wireless/b43legacy/main.c b/drivers/net/wireless/b43legacy/main.c
index ef829ee8ffd4..14a5eea2573e 100644
--- a/drivers/net/wireless/b43legacy/main.c
+++ b/drivers/net/wireless/b43legacy/main.c
@@ -1720,7 +1720,7 @@ static int b43legacy_write_initvals(struct b43legacy_wldev *dev,
                                 goto err_format;
                         array_size -= sizeof(iv->data.d32);
 
-                        value = be32_to_cpu(get_unaligned(&iv->data.d32));
+                        value = get_unaligned_be32(&iv->data.d32);
                         b43legacy_write32(dev, offset, value);
 
                         iv = (const struct b43legacy_iv *)((const uint8_t *)iv +
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index 598e4eef4f40..d3406830c8e3 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -554,40 +554,36 @@ static void iwl3945_add_radiotap(struct iwl3945_priv *priv,
         iwl3945_rt->rt_hdr.it_pad = 0;
 
         /* total header + data */
-        put_unaligned(cpu_to_le16(sizeof(*iwl3945_rt)),
-                      &iwl3945_rt->rt_hdr.it_len);
+        put_unaligned_le16(sizeof(*iwl3945_rt), &iwl3945_rt->rt_hdr.it_len);
 
         /* Indicate all the fields we add to the radiotap header */
-        put_unaligned(cpu_to_le32((1 << IEEE80211_RADIOTAP_TSFT) |
-                                  (1 << IEEE80211_RADIOTAP_FLAGS) |
-                                  (1 << IEEE80211_RADIOTAP_RATE) |
-                                  (1 << IEEE80211_RADIOTAP_CHANNEL) |
-                                  (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
-                                  (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
-                                  (1 << IEEE80211_RADIOTAP_ANTENNA)),
-                      &iwl3945_rt->rt_hdr.it_present);
+        put_unaligned_le32((1 << IEEE80211_RADIOTAP_TSFT) |
+                           (1 << IEEE80211_RADIOTAP_FLAGS) |
+                           (1 << IEEE80211_RADIOTAP_RATE) |
+                           (1 << IEEE80211_RADIOTAP_CHANNEL) |
+                           (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
+                           (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
+                           (1 << IEEE80211_RADIOTAP_ANTENNA),
+                        &iwl3945_rt->rt_hdr.it_present);
 
         /* Zero the flags, we'll add to them as we go */
         iwl3945_rt->rt_flags = 0;
 
-        put_unaligned(cpu_to_le64(tsf), &iwl3945_rt->rt_tsf);
+        put_unaligned_le64(tsf, &iwl3945_rt->rt_tsf);
 
         iwl3945_rt->rt_dbmsignal = signal;
         iwl3945_rt->rt_dbmnoise = noise;
 
         /* Convert the channel frequency and set the flags */
-        put_unaligned(cpu_to_le16(stats->freq), &iwl3945_rt->rt_channelMHz);
+        put_unaligned_le16(stats->freq, &iwl3945_rt->rt_channelMHz);
         if (!(phy_flags_hw & RX_RES_PHY_FLAGS_BAND_24_MSK))
-                put_unaligned(cpu_to_le16(IEEE80211_CHAN_OFDM |
-                                          IEEE80211_CHAN_5GHZ),
+                put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ,
                               &iwl3945_rt->rt_chbitmask);
         else if (phy_flags_hw & RX_RES_PHY_FLAGS_MOD_CCK_MSK)
-                put_unaligned(cpu_to_le16(IEEE80211_CHAN_CCK |
-                                          IEEE80211_CHAN_2GHZ),
+                put_unaligned_le16(IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ,
                               &iwl3945_rt->rt_chbitmask);
         else    /* 802.11g */
-                put_unaligned(cpu_to_le16(IEEE80211_CHAN_OFDM |
-                                          IEEE80211_CHAN_2GHZ),
+                put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ,
                               &iwl3945_rt->rt_chbitmask);
 
         if (rate == -1)
diff --git a/drivers/net/wireless/libertas/scan.c b/drivers/net/wireless/libertas/scan.c
index 7234669d05c0..d448c9702a0f 100644
--- a/drivers/net/wireless/libertas/scan.c
+++ b/drivers/net/wireless/libertas/scan.c
@@ -523,7 +523,7 @@ static int lbs_process_bss(struct bss_descriptor *bss,
 
         if (*bytesleft >= sizeof(beaconsize)) {
                 /* Extract & convert beacon size from the command buffer */
-                beaconsize = le16_to_cpu(get_unaligned((__le16 *)*pbeaconinfo));
+                beaconsize = get_unaligned_le16(*pbeaconinfo);
                 *bytesleft -= sizeof(beaconsize);
                 *pbeaconinfo += sizeof(beaconsize);
         }
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index bced3fe1cf8a..5dd23c93497d 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -768,41 +768,17 @@ static __u8 *UnStuffData(__u8 * src, __u8 * end, __u8 * dst,
 /* General routines for STRIP                                           */
 
 /*
- * get_baud returns the current baud rate, as one of the constants defined in
- * termbits.h
- * If the user has issued a baud rate override using the 'setserial' command
- * and the logical current rate is set to 38.4, then the true baud rate
- * currently in effect (57.6 or 115.2) is returned.
- */
-static unsigned int get_baud(struct tty_struct *tty)
-{
-        if (!tty || !tty->termios)
-                return (0);
-        if ((tty->termios->c_cflag & CBAUD) == B38400 && tty->driver_data) {
-                struct async_struct *info =
-                    (struct async_struct *) tty->driver_data;
-                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        return (B57600);
-                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        return (B115200);
-        }
-        return (tty->termios->c_cflag & CBAUD);
-}
-
-/*
  * set_baud sets the baud rate to the rate defined by baudcode
- * Note: The rate B38400 should be avoided, because the user may have
- * issued a 'setserial' speed override to map that to a different speed.
- * We could achieve a true rate of 38400 if we needed to by cancelling
- * any user speed override that is in place, but that might annoy the
- * user, so it is simplest to just avoid using 38400.
  */
-static void set_baud(struct tty_struct *tty, unsigned int baudcode)
+static void set_baud(struct tty_struct *tty, speed_t baudrate)
 {
-        struct ktermios old_termios = *(tty->termios);
-        tty->termios->c_cflag &= ~CBAUD;        /* Clear the old baud setting */
-        tty->termios->c_cflag |= baudcode;      /* Set the new baud setting */
-        tty->driver->set_termios(tty, &old_termios);
+        struct ktermios old_termios;
+
+        mutex_lock(&tty->termios_mutex);
+        old_termios =*(tty->termios);
+        tty_encode_baud_rate(tty, baudrate, baudrate);
+        tty->ops->set_termios(tty, &old_termios);
+        mutex_unlock(&tty->termios_mutex);
 }
 
 /*
@@ -1217,7 +1193,7 @@ static void ResetRadio(struct strip *strip_info)
         strip_info->watchdog_doreset = jiffies + 1 * HZ;
 
         /* If the user has selected a baud rate above 38.4 see what magic we have to do */
-        if (strip_info->user_baud > B38400) {
+        if (strip_info->user_baud > 38400) {
                 /*
                  * Subtle stuff: Pay attention :-)
                  * If the serial port is currently at the user's selected (>38.4) rate,
@@ -1227,17 +1203,17 @@ static void ResetRadio(struct strip *strip_info)
                  * issued the ATS304 command last time through, so this time we restore
                  * the user's selected rate and issue the normal starmode reset string.
                  */
-                if (strip_info->user_baud == get_baud(tty)) {
+                if (strip_info->user_baud == tty_get_baud_rate(tty)) {
                         static const char b0[] = "ate0q1s304=57600\r";
                         static const char b1[] = "ate0q1s304=115200\r";
                         static const StringDescriptor baudstring[2] =
                             { {b0, sizeof(b0) - 1}
                         , {b1, sizeof(b1) - 1}
                         };
-                        set_baud(tty, B19200);
-                        if (strip_info->user_baud == B57600)
+                        set_baud(tty, 19200);
+                        if (strip_info->user_baud == 57600)
                                 s = baudstring[0];
-                        else if (strip_info->user_baud == B115200)
+                        else if (strip_info->user_baud == 115200)
                                 s = baudstring[1];
                         else
                                 s = baudstring[1];      /* For now */
@@ -1245,7 +1221,7 @@ static void ResetRadio(struct strip *strip_info)
                         set_baud(tty, strip_info->user_baud);
         }
 
-        tty->driver->write(tty, s.string, s.length);
+        tty->ops->write(tty, s.string, s.length);
 #ifdef EXT_COUNTERS
         strip_info->tx_ebytes += s.length;
 #endif
@@ -1267,7 +1243,7 @@ static void strip_write_some_more(struct tty_struct *tty)
 
         if (strip_info->tx_left > 0) {
                 int num_written =
-                    tty->driver->write(tty, strip_info->tx_head,
+                    tty->ops->write(tty, strip_info->tx_head,
                                       strip_info->tx_left);
                 strip_info->tx_left -= num_written;
                 strip_info->tx_head += num_written;
@@ -2457,7 +2433,7 @@ static int strip_open_low(struct net_device *dev)
         strip_info->working = FALSE;
         strip_info->firmware_level = NoStructure;
         strip_info->next_command = CompatibilityCommand;
-        strip_info->user_baud = get_baud(strip_info->tty);
+        strip_info->user_baud = tty_get_baud_rate(strip_info->tty);
 
         printk(KERN_INFO "%s: Initializing Radio.\n",
                strip_info->dev->name);
@@ -2632,6 +2608,13 @@ static int strip_open(struct tty_struct *tty)
                 return -EEXIST;
 
         /*
+         * We need a write method.
+         */
+
+        if (tty->ops->write == NULL)
+                return -EOPNOTSUPP;
+
+        /*
          * OK.  Find a free STRIP channel to use.
          */
         if ((strip_info = strip_alloc()) == NULL)
@@ -2652,8 +2635,7 @@ static int strip_open(struct tty_struct *tty)
         tty->disc_data = strip_info;
         tty->receive_room = 65536;
 
-        if (tty->driver->flush_buffer)
-                tty->driver->flush_buffer(tty);
+        tty_driver_flush_buffer(tty);
 
         /*
          * Restore default settings
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index e34675c2f8fc..5316074f39f0 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -545,11 +545,11 @@ static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
          * be padded. Unaligned access might also happen if the length_info
          * structure is not present.
          */
-        if (get_unaligned(&length_info->tag) == cpu_to_le16(RX_LENGTH_INFO_TAG))
+        if (get_unaligned_le16(&length_info->tag) == RX_LENGTH_INFO_TAG)
         {
                 unsigned int l, k, n;
                 for (i = 0, l = 0;; i++) {
-                        k = le16_to_cpu(get_unaligned(&length_info->length[i]));
+                        k = get_unaligned_le16(&length_info->length[i]);
                         if (k == 0)
                                 return;
                         n = l+k;