mlx4: Apply spatch to files imported from Linux
authorXiao Jia <stfairy@gmail.com>
Wed, 16 Sep 2015 23:08:11 +0000 (16:08 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 23 Sep 2015 17:49:29 +0000 (13:49 -0400)
The following commands were executed repeatedly until convergence.

scripts/spatch/spatch-me.sh scripts/spatch/linux/scalar.cocci yes kern/drivers/net/mlx4/
scripts/spatch/spatch-me.sh scripts/spatch/linux/scalar.cocci yes kern/include/linux/
scripts/spatch/spatch-me.sh scripts/spatch/linux/sync.cocci yes kern/drivers/net/mlx4/
scripts/spatch/spatch-me.sh scripts/spatch/linux/sync.cocci yes kern/include/linux/
scripts/spatch/spatch-me.sh scripts/spatch/linux/memory.cocci yes kern/drivers/net/mlx4/
scripts/spatch/spatch-me.sh scripts/spatch/linux/memory.cocci yes kern/include/linux/
scripts/spatch/spatch-me.sh scripts/spatch/linux/funcs.cocci yes kern/drivers/net/mlx4/
scripts/spatch/spatch-me.sh scripts/spatch/linux/funcs.cocci yes kern/include/linux/
scripts/spatch/spatch-me.sh scripts/spatch/linux/io_funcs.cocci yes kern/drivers/net/mlx4/
scripts/spatch/spatch-me.sh scripts/spatch/linux/io_funcs.cocci yes kern/include/linux/

48 files changed:
kern/drivers/net/mlx4/alloc.c
kern/drivers/net/mlx4/catas.c
kern/drivers/net/mlx4/cmd.c
kern/drivers/net/mlx4/cq.c
kern/drivers/net/mlx4/en_clock.c
kern/drivers/net/mlx4/en_cq.c
kern/drivers/net/mlx4/en_dcb_nl.c
kern/drivers/net/mlx4/en_ethtool.c
kern/drivers/net/mlx4/en_main.c
kern/drivers/net/mlx4/en_netdev.c
kern/drivers/net/mlx4/en_port.c
kern/drivers/net/mlx4/en_port.h
kern/drivers/net/mlx4/en_resources.c
kern/drivers/net/mlx4/en_rx.c
kern/drivers/net/mlx4/en_selftest.c
kern/drivers/net/mlx4/en_tx.c
kern/drivers/net/mlx4/eq.c
kern/drivers/net/mlx4/fw.c
kern/drivers/net/mlx4/fw.h
kern/drivers/net/mlx4/fw_qos.c
kern/drivers/net/mlx4/fw_qos.h
kern/drivers/net/mlx4/icm.c
kern/drivers/net/mlx4/icm.h
kern/drivers/net/mlx4/intf.c
kern/drivers/net/mlx4/main.c
kern/drivers/net/mlx4/mcg.c
kern/drivers/net/mlx4/mlx4.h
kern/drivers/net/mlx4/mlx4_en.h
kern/drivers/net/mlx4/mlx4_stats.h
kern/drivers/net/mlx4/mr.c
kern/drivers/net/mlx4/pd.c
kern/drivers/net/mlx4/port.c
kern/drivers/net/mlx4/profile.c
kern/drivers/net/mlx4/qp.c
kern/drivers/net/mlx4/reset.c
kern/drivers/net/mlx4/resource_tracker.c
kern/drivers/net/mlx4/sense.c
kern/drivers/net/mlx4/srq.c
kern/include/linux/mlx4/cmd.h
kern/include/linux/mlx4/cq.h
kern/include/linux/mlx4/device.h
kern/include/linux/mlx4/doorbell.h
kern/include/linux/mlx4/driver.h
kern/include/linux/mlx4/qp.h
kern/include/linux/mlx4/srq.h
kern/include/linux/rdma/ib_mad.h
kern/include/linux/rdma/ib_smi.h
kern/include/linux/rdma/ib_verbs.h

index 0c51c69..016c89a 100644 (file)
@@ -41,9 +41,9 @@
 
 #include "mlx4.h"
 
-u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
+uint32_t mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
 {
-       u32 obj;
+       uint32_t obj;
 
        spin_lock(&bitmap->lock);
 
@@ -71,14 +71,15 @@ u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
        return obj;
 }
 
-void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, u32 obj, int use_rr)
+void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, uint32_t obj, int use_rr)
 {
        mlx4_bitmap_free_range(bitmap, obj, 1, use_rr);
 }
 
 static unsigned long find_aligned_range(unsigned long *bitmap,
-                                       u32 start, u32 nbits,
-                                       int len, int align, u32 skip_mask)
+                                       uint32_t start, uint32_t nbits,
+                                       int len, int align,
+                                       uint32_t skip_mask)
 {
        unsigned long end, i;
 
@@ -97,7 +98,7 @@ again:
                return -1;
 
        for (i = start + 1; i < end; i++) {
-               if (test_bit(i, bitmap) || ((u32)i & skip_mask)) {
+               if (test_bit(i, bitmap) || ((uint32_t)i & skip_mask)) {
                        start = i + 1;
                        goto again;
                }
@@ -106,10 +107,10 @@ again:
        return start;
 }
 
-u32 mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt,
-                           int align, u32 skip_mask)
+uint32_t mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt,
+                           int align, uint32_t skip_mask)
 {
-       u32 obj;
+       uint32_t obj;
 
        if (likely(cnt == 1 && align == 1 && !skip_mask))
                return mlx4_bitmap_alloc(bitmap);
@@ -144,24 +145,25 @@ u32 mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt,
        return obj;
 }
 
-u32 mlx4_bitmap_avail(struct mlx4_bitmap *bitmap)
+uint32_t mlx4_bitmap_avail(struct mlx4_bitmap *bitmap)
 {
        return bitmap->avail;
 }
 
-static u32 mlx4_bitmap_masked_value(struct mlx4_bitmap *bitmap, u32 obj)
+static uint32_t mlx4_bitmap_masked_value(struct mlx4_bitmap *bitmap,
+                                        uint32_t obj)
 {
        return obj & (bitmap->max + bitmap->reserved_top - 1);
 }
 
-void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt,
+void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, uint32_t obj, int cnt,
                            int use_rr)
 {
        obj &= bitmap->max + bitmap->reserved_top - 1;
 
        spin_lock(&bitmap->lock);
        if (!use_rr) {
-               bitmap->last = min(bitmap->last, obj);
+               bitmap->last = MIN(bitmap->last, obj);
                bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
                                & bitmap->mask;
        }
@@ -170,11 +172,11 @@ void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt,
        spin_unlock(&bitmap->lock);
 }
 
-int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask,
-                    u32 reserved_bot, u32 reserved_top)
+int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, uint32_t num, uint32_t mask,
+                    uint32_t reserved_bot, uint32_t reserved_top)
 {
        /* num must be a power of 2 */
-       if (num != roundup_pow_of_two(num))
+       if (num != ROUNDUPPWR2(num))
                return -EINVAL;
 
        bitmap->last = 0;
@@ -184,9 +186,9 @@ int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask,
        bitmap->reserved_top = reserved_top;
        bitmap->avail = num - reserved_top - reserved_bot;
        bitmap->effective_len = bitmap->avail;
-       spin_lock_init(&bitmap->lock);
-       bitmap->table = kzalloc(BITS_TO_LONGS(bitmap->max) *
-                               sizeof (long), GFP_KERNEL);
+       spinlock_init_irqsave(&bitmap->lock);
+       bitmap->table = kzmalloc(BITS_TO_LONGS(bitmap->max) * sizeof(long),
+                                KMALLOC_WAIT);
        if (!bitmap->table)
                return -ENOMEM;
 
@@ -203,8 +205,8 @@ void mlx4_bitmap_cleanup(struct mlx4_bitmap *bitmap)
 struct mlx4_zone_allocator {
        struct list_head                entries;
        struct list_head                prios;
-       u32                             last_uid;
-       u32                             mask;
+       uint32_t                                last_uid;
+       uint32_t                                mask;
        /* protect the zone_allocator from concurrent accesses */
        spinlock_t                      lock;
        enum mlx4_zone_alloc_flags      flags;
@@ -213,7 +215,7 @@ struct mlx4_zone_allocator {
 struct mlx4_zone_entry {
        struct list_head                list;
        struct list_head                prio_list;
-       u32                             uid;
+       uint32_t                                uid;
        struct mlx4_zone_allocator      *allocator;
        struct mlx4_bitmap              *bitmap;
        int                             use_rr;
@@ -224,14 +226,15 @@ struct mlx4_zone_entry {
 
 struct mlx4_zone_allocator *mlx4_zone_allocator_create(enum mlx4_zone_alloc_flags flags)
 {
-       struct mlx4_zone_allocator *zones = kmalloc(sizeof(*zones), GFP_KERNEL);
+       struct mlx4_zone_allocator *zones = kmalloc(sizeof(*zones),
+                                                   KMALLOC_WAIT);
 
        if (NULL == zones)
                return NULL;
 
        INIT_LIST_HEAD(&zones->entries);
        INIT_LIST_HEAD(&zones->prios);
-       spin_lock_init(&zones->lock);
+       spinlock_init_irqsave(&zones->lock);
        zones->last_uid = 0;
        zones->mask = 0;
        zones->flags = flags;
@@ -241,14 +244,14 @@ struct mlx4_zone_allocator *mlx4_zone_allocator_create(enum mlx4_zone_alloc_flag
 
 int mlx4_zone_add_one(struct mlx4_zone_allocator *zone_alloc,
                      struct mlx4_bitmap *bitmap,
-                     u32 flags,
+                     uint32_t flags,
                      int priority,
                      int offset,
-                     u32 *puid)
+                     uint32_t *puid)
 {
-       u32 mask = mlx4_bitmap_masked_value(bitmap, (u32)-1);
+       uint32_t mask = mlx4_bitmap_masked_value(bitmap, (uint32_t)-1);
        struct mlx4_zone_entry *it;
-       struct mlx4_zone_entry *zone = kmalloc(sizeof(*zone), GFP_KERNEL);
+       struct mlx4_zone_entry *zone = kmalloc(sizeof(*zone), KMALLOC_WAIT);
 
        if (NULL == zone)
                return -ENOMEM;
@@ -304,11 +307,12 @@ static int __mlx4_zone_remove_one_entry(struct mlx4_zone_entry *entry)
        list_del(&entry->list);
 
        if (zone_alloc->flags & MLX4_ZONE_ALLOC_FLAGS_NO_OVERLAP) {
-               u32 mask = 0;
+               uint32_t mask = 0;
                struct mlx4_zone_entry *it;
 
                list_for_each_entry(it, &zone_alloc->prios, prio_list) {
-                       u32 cur_mask = mlx4_bitmap_masked_value(it->bitmap, (u32)-1);
+                       uint32_t cur_mask = mlx4_bitmap_masked_value(it->bitmap,
+                                                                    (uint32_t)-1);
 
                        if (mask < cur_mask)
                                mask = cur_mask;
@@ -336,18 +340,19 @@ void mlx4_zone_allocator_destroy(struct mlx4_zone_allocator *zone_alloc)
 }
 
 /* Should be called under a lock */
-static u32 __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
-                                 int align, u32 skip_mask, u32 *puid)
+static uint32_t __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
+                                 int align, uint32_t skip_mask,
+                                 uint32_t *puid)
 {
-       u32 uid;
-       u32 res;
+       uint32_t uid;
+       uint32_t res;
        struct mlx4_zone_allocator *zone_alloc = zone->allocator;
        struct mlx4_zone_entry *curr_node;
 
        res = mlx4_bitmap_alloc_range(zone->bitmap, count,
                                      align, skip_mask);
 
-       if (res != (u32)-1) {
+       if (res != (uint32_t)-1) {
                res += zone->offset;
                uid = zone->uid;
                goto out;
@@ -364,7 +369,7 @@ static u32 __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
                list_for_each_entry_continue_reverse(it, &zone_alloc->entries, list) {
                        res = mlx4_bitmap_alloc_range(it->bitmap, count,
                                                      align, skip_mask);
-                       if (res != (u32)-1) {
+                       if (res != (uint32_t)-1) {
                                res += it->offset;
                                uid = it->uid;
                                goto out;
@@ -384,7 +389,7 @@ static u32 __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
 
                        res = mlx4_bitmap_alloc_range(it->bitmap, count,
                                                      align, skip_mask);
-                       if (res != (u32)-1) {
+                       if (res != (uint32_t)-1) {
                                res += it->offset;
                                uid = it->uid;
                                goto out;
@@ -403,7 +408,7 @@ static u32 __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
                list_for_each_entry_from(curr_node, &zone_alloc->entries, list) {
                        res = mlx4_bitmap_alloc_range(curr_node->bitmap, count,
                                                      align, skip_mask);
-                       if (res != (u32)-1) {
+                       if (res != (uint32_t)-1) {
                                res += curr_node->offset;
                                uid = curr_node->uid;
                                goto out;
@@ -412,21 +417,21 @@ static u32 __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
        }
 
 out:
-       if (NULL != puid && res != (u32)-1)
+       if (NULL != puid && res != (uint32_t)-1)
                *puid = uid;
        return res;
 }
 
 /* Should be called under a lock */
-static void __mlx4_free_from_zone(struct mlx4_zone_entry *zone, u32 obj,
-                                 u32 count)
+static void __mlx4_free_from_zone(struct mlx4_zone_entry *zone, uint32_t obj,
+                                 uint32_t count)
 {
        mlx4_bitmap_free_range(zone->bitmap, obj - zone->offset, count, zone->use_rr);
 }
 
 /* Should be called under a lock */
 static struct mlx4_zone_entry *__mlx4_find_zone_by_uid(
-               struct mlx4_zone_allocator *zones, u32 uid)
+               struct mlx4_zone_allocator *zones, uint32_t uid)
 {
        struct mlx4_zone_entry *zone;
 
@@ -438,7 +443,8 @@ static struct mlx4_zone_entry *__mlx4_find_zone_by_uid(
        return NULL;
 }
 
-struct mlx4_bitmap *mlx4_zone_get_bitmap(struct mlx4_zone_allocator *zones, u32 uid)
+struct mlx4_bitmap *mlx4_zone_get_bitmap(struct mlx4_zone_allocator *zones,
+                                        uint32_t uid)
 {
        struct mlx4_zone_entry *zone;
        struct mlx4_bitmap *bitmap;
@@ -454,7 +460,7 @@ struct mlx4_bitmap *mlx4_zone_get_bitmap(struct mlx4_zone_allocator *zones, u32
        return bitmap;
 }
 
-int mlx4_zone_remove_one(struct mlx4_zone_allocator *zones, u32 uid)
+int mlx4_zone_remove_one(struct mlx4_zone_allocator *zones, uint32_t uid)
 {
        struct mlx4_zone_entry *zone;
        int res;
@@ -479,10 +485,10 @@ out:
 
 /* Should be called under a lock */
 static struct mlx4_zone_entry *__mlx4_find_zone_by_uid_unique(
-               struct mlx4_zone_allocator *zones, u32 obj)
+               struct mlx4_zone_allocator *zones, uint32_t obj)
 {
        struct mlx4_zone_entry *zone, *zone_candidate = NULL;
-       u32 dist = (u32)-1;
+       uint32_t dist = (uint32_t)-1;
 
        /* Search for the smallest zone that this obj could be
         * allocated from. This is done in order to handle
@@ -492,10 +498,10 @@ static struct mlx4_zone_entry *__mlx4_find_zone_by_uid_unique(
         */
        list_for_each_entry(zone, &zones->entries, list) {
                if (obj >= zone->offset) {
-                       u32 mobj = (obj - zone->offset) & zones->mask;
+                       uint32_t mobj = (obj - zone->offset) & zones->mask;
 
                        if (mobj < zone->bitmap->max) {
-                               u32 curr_dist = zone->bitmap->effective_len;
+                               uint32_t curr_dist = zone->bitmap->effective_len;
 
                                if (curr_dist < dist) {
                                        dist = curr_dist;
@@ -508,8 +514,10 @@ static struct mlx4_zone_entry *__mlx4_find_zone_by_uid_unique(
        return zone_candidate;
 }
 
-u32 mlx4_zone_alloc_entries(struct mlx4_zone_allocator *zones, u32 uid, int count,
-                           int align, u32 skip_mask, u32 *puid)
+uint32_t mlx4_zone_alloc_entries(struct mlx4_zone_allocator *zones,
+                                uint32_t uid, int count,
+                                int align, uint32_t skip_mask,
+                                uint32_t *puid)
 {
        struct mlx4_zone_entry *zone;
        int res = -1;
@@ -529,7 +537,8 @@ out:
        return res;
 }
 
-u32 mlx4_zone_free_entries(struct mlx4_zone_allocator *zones, u32 uid, u32 obj, u32 count)
+uint32_t mlx4_zone_free_entries(struct mlx4_zone_allocator *zones,
+                               uint32_t uid, uint32_t obj, uint32_t count)
 {
        struct mlx4_zone_entry *zone;
        int res = 0;
@@ -551,7 +560,8 @@ out:
        return res;
 }
 
-u32 mlx4_zone_free_entries_unique(struct mlx4_zone_allocator *zones, u32 obj, u32 count)
+uint32_t mlx4_zone_free_entries_unique(struct mlx4_zone_allocator *zones,
+                                      uint32_t obj, uint32_t count)
 {
        struct mlx4_zone_entry *zone;
        int res;
@@ -612,8 +622,8 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
                buf->nbufs       = (size + PAGE_SIZE - 1) / PAGE_SIZE;
                buf->npages      = buf->nbufs;
                buf->page_shift  = PAGE_SHIFT;
-               buf->page_list   = kcalloc(buf->nbufs, sizeof(*buf->page_list),
-                                          gfp);
+               buf->page_list   = kzmalloc((buf->nbufs) * (sizeof(*buf->page_list)),
+                                           gfp);
                if (!buf->page_list)
                        return -ENOMEM;
 
@@ -636,7 +646,7 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
                        if (!pages)
                                goto err_free;
                        for (i = 0; i < buf->nbufs; ++i)
-                               pages[i] = virt_to_page(buf->page_list[i].buf);
+                               pages[i] = kva2page(buf->page_list[i].buf);
                        buf->direct.buf = vmap(pages, buf->nbufs, VM_MAP, PAGE_KERNEL);
                        kfree(pages);
                        if (!buf->direct.buf)
@@ -681,7 +691,7 @@ static struct mlx4_db_pgdir *mlx4_alloc_db_pgdir(struct device *dma_device,
 {
        struct mlx4_db_pgdir *pgdir;
 
-       pgdir = kzalloc(sizeof *pgdir, gfp);
+       pgdir = kzmalloc(sizeof *pgdir, gfp);
        if (!pgdir)
                return NULL;
 
@@ -735,7 +745,7 @@ int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp
        struct mlx4_db_pgdir *pgdir;
        int ret = 0;
 
-       mutex_lock(&priv->pgdir_mutex);
+       qlock(&priv->pgdir_mutex);
 
        list_for_each_entry(pgdir, &priv->pgdir_list, list)
                if (!mlx4_alloc_db_from_pgdir(pgdir, db, order))
@@ -750,10 +760,10 @@ int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp
        list_add(&pgdir->list, &priv->pgdir_list);
 
        /* This should never fail -- we just allocated an empty page: */
-       WARN_ON(mlx4_alloc_db_from_pgdir(pgdir, db, order));
+       warn_on(mlx4_alloc_db_from_pgdir(pgdir, db, order));
 
 out:
-       mutex_unlock(&priv->pgdir_mutex);
+       qunlock(&priv->pgdir_mutex);
 
        return ret;
 }
@@ -765,7 +775,7 @@ void mlx4_db_free(struct mlx4_dev *dev, struct mlx4_db *db)
        int o;
        int i;
 
-       mutex_lock(&priv->pgdir_mutex);
+       qlock(&priv->pgdir_mutex);
 
        o = db->order;
        i = db->index;
@@ -784,7 +794,7 @@ void mlx4_db_free(struct mlx4_dev *dev, struct mlx4_db *db)
                kfree(db->u.pgdir);
        }
 
-       mutex_unlock(&priv->pgdir_mutex);
+       qunlock(&priv->pgdir_mutex);
 }
 EXPORT_SYMBOL_GPL(mlx4_db_free);
 
@@ -793,13 +803,13 @@ int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
 {
        int err;
 
-       err = mlx4_db_alloc(dev, &wqres->db, 1, GFP_KERNEL);
+       err = mlx4_db_alloc(dev, &wqres->db, 1, KMALLOC_WAIT);
        if (err)
                return err;
 
        *wqres->db.db = 0;
 
-       err = mlx4_buf_alloc(dev, size, max_direct, &wqres->buf, GFP_KERNEL);
+       err = mlx4_buf_alloc(dev, size, max_direct, &wqres->buf, KMALLOC_WAIT);
        if (err)
                goto err_db;
 
@@ -808,7 +818,7 @@ int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
        if (err)
                goto err_buf;
 
-       err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf, GFP_KERNEL);
+       err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf, KMALLOC_WAIT);
        if (err)
                goto err_mtt;
 
index 715de8a..b945e73 100644 (file)
@@ -49,7 +49,7 @@ MODULE_PARM_DESC(internal_err_reset,
 
 static int read_vendor_id(struct mlx4_dev *dev)
 {
-       u16 vendor_id = 0;
+       uint16_t vendor_id = 0;
        int ret;
 
        ret = pci_read_config_word(dev->persist->pdev, 0, &vendor_id);
@@ -94,17 +94,17 @@ static int mlx4_reset_slave(struct mlx4_dev *dev)
 #define COM_CHAN_RST_REQ_OFFSET 0x10
 #define COM_CHAN_RST_ACK_OFFSET 0x08
 
-       u32 comm_flags;
-       u32 rst_req;
-       u32 rst_ack;
+       uint32_t comm_flags;
+       uint32_t rst_req;
+       uint32_t rst_ack;
        unsigned long end;
        struct mlx4_priv *priv = mlx4_priv(dev);
 
        if (pci_channel_offline(dev->persist->pdev))
                return 0;
 
-       comm_flags = swab32(readl((__iomem char *)priv->mfunc.comm +
-                                 MLX4_COMM_CHAN_FLAGS));
+       comm_flags = swab32(read32((__iomem char *)priv->mfunc.comm +
+                                  MLX4_COMM_CHAN_FLAGS));
        if (comm_flags == 0xffffffff) {
                mlx4_err(dev, "VF reset is not needed\n");
                return 0;
@@ -115,9 +115,9 @@ static int mlx4_reset_slave(struct mlx4_dev *dev)
                return -EOPNOTSUPP;
        }
 
-       rst_req = (comm_flags & (u32)(1 << COM_CHAN_RST_REQ_OFFSET)) >>
+       rst_req = (comm_flags & (uint32_t)(1 << COM_CHAN_RST_REQ_OFFSET)) >>
                COM_CHAN_RST_REQ_OFFSET;
-       rst_ack = (comm_flags & (u32)(1 << COM_CHAN_RST_ACK_OFFSET)) >>
+       rst_ack = (comm_flags & (uint32_t)(1 << COM_CHAN_RST_ACK_OFFSET)) >>
                COM_CHAN_RST_ACK_OFFSET;
        if (rst_req != rst_ack) {
                mlx4_err(dev, "Communication channel isn't sync, fail to send reset\n");
@@ -127,25 +127,25 @@ static int mlx4_reset_slave(struct mlx4_dev *dev)
        rst_req ^= 1;
        mlx4_warn(dev, "VF is sending reset request to Firmware\n");
        comm_flags = rst_req << COM_CHAN_RST_REQ_OFFSET;
-       __raw_writel((__force u32)cpu_to_be32(comm_flags),
+       __raw_write32((__force uint32_t)cpu_to_be32(comm_flags),
                     (__iomem char *)priv->mfunc.comm + MLX4_COMM_CHAN_FLAGS);
        /* Make sure that our comm channel write doesn't
         * get mixed in with writes from another CPU.
         */
-       mmiowb();
+       bus_wmb();
 
        end = msecs_to_jiffies(MLX4_COMM_TIME) + jiffies;
        while (time_before(jiffies, end)) {
-               comm_flags = swab32(readl((__iomem char *)priv->mfunc.comm +
-                                         MLX4_COMM_CHAN_FLAGS));
-               rst_ack = (comm_flags & (u32)(1 << COM_CHAN_RST_ACK_OFFSET)) >>
+               comm_flags = swab32(read32((__iomem char *)priv->mfunc.comm +
+                                          MLX4_COMM_CHAN_FLAGS));
+               rst_ack = (comm_flags & (uint32_t)(1 << COM_CHAN_RST_ACK_OFFSET)) >>
                        COM_CHAN_RST_ACK_OFFSET;
 
                /* Reading rst_req again since the communication channel can
                 * be reset at any time by the PF and all its bits will be
                 * set to zero.
                 */
-               rst_req = (comm_flags & (u32)(1 << COM_CHAN_RST_REQ_OFFSET)) >>
+               rst_req = (comm_flags & (uint32_t)(1 << COM_CHAN_RST_REQ_OFFSET)) >>
                        COM_CHAN_RST_REQ_OFFSET;
 
                if (rst_ack == rst_req) {
@@ -158,10 +158,10 @@ static int mlx4_reset_slave(struct mlx4_dev *dev)
        return -ETIMEDOUT;
 }
 
-static int mlx4_comm_internal_err(u32 slave_read)
+static int mlx4_comm_internal_err(uint32_t slave_read)
 {
-       return (u32)COMM_CHAN_EVENT_INTERNAL_ERR ==
-               (slave_read & (u32)COMM_CHAN_EVENT_INTERNAL_ERR) ? 1 : 0;
+       return (uint32_t)COMM_CHAN_EVENT_INTERNAL_ERR ==
+               (slave_read & (uint32_t)COMM_CHAN_EVENT_INTERNAL_ERR) ? 1 : 0;
 }
 
 void mlx4_enter_error_state(struct mlx4_dev_persistent *persist)
@@ -172,7 +172,7 @@ void mlx4_enter_error_state(struct mlx4_dev_persistent *persist)
        if (!mlx4_internal_err_reset)
                return;
 
-       mutex_lock(&persist->device_state_mutex);
+       qlock(&persist->device_state_mutex);
        if (persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
                goto out;
 
@@ -182,11 +182,11 @@ void mlx4_enter_error_state(struct mlx4_dev_persistent *persist)
                err = mlx4_reset_slave(dev);
        else
                err = mlx4_reset_master(dev);
-       BUG_ON(err != 0);
+       assert(!(err != 0));
 
        dev->persist->state |= MLX4_DEVICE_STATE_INTERNAL_ERROR;
        mlx4_err(dev, "device was reset successfully\n");
-       mutex_unlock(&persist->device_state_mutex);
+       qunlock(&persist->device_state_mutex);
 
        /* At that step HW was already reset, now notify clients */
        mlx4_dispatch_event(dev, MLX4_DEV_EVENT_CATASTROPHIC_ERROR, 0);
@@ -194,7 +194,7 @@ void mlx4_enter_error_state(struct mlx4_dev_persistent *persist)
        return;
 
 out:
-       mutex_unlock(&persist->device_state_mutex);
+       qunlock(&persist->device_state_mutex);
 }
 
 static void mlx4_handle_error_state(struct mlx4_dev_persistent *persist)
@@ -202,14 +202,14 @@ static void mlx4_handle_error_state(struct mlx4_dev_persistent *persist)
        int err = 0;
 
        mlx4_enter_error_state(persist);
-       mutex_lock(&persist->interface_state_mutex);
+       qlock(&persist->interface_state_mutex);
        if (persist->interface_state & MLX4_INTERFACE_STATE_UP &&
            !(persist->interface_state & MLX4_INTERFACE_STATE_DELETION)) {
                err = mlx4_restart_one(persist->pdev);
                mlx4_info(persist->dev, "mlx4_restart_one was ended, ret=%d\n",
                          err);
        }
-       mutex_unlock(&persist->interface_state_mutex);
+       qunlock(&persist->interface_state_mutex);
 }
 
 static void dump_err_buf(struct mlx4_dev *dev)
@@ -221,22 +221,22 @@ static void dump_err_buf(struct mlx4_dev *dev)
        mlx4_err(dev, "Internal error detected:\n");
        for (i = 0; i < priv->fw.catas_size; ++i)
                mlx4_err(dev, "  buf[%02x]: %08x\n",
-                        i, swab32(readl(priv->catas_err.map + i)));
+                        i, swab32(read32(priv->catas_err.map + i)));
 }
 
 static void poll_catas(unsigned long dev_ptr)
 {
        struct mlx4_dev *dev = (struct mlx4_dev *) dev_ptr;
        struct mlx4_priv *priv = mlx4_priv(dev);
-       u32 slave_read;
+       uint32_t slave_read;
 
        if (mlx4_is_slave(dev)) {
-               slave_read = swab32(readl(&priv->mfunc.comm->slave_read));
+               slave_read = swab32(read32(&priv->mfunc.comm->slave_read));
                if (mlx4_comm_internal_err(slave_read)) {
                        mlx4_warn(dev, "Internal error detected on the communication channel\n");
                        goto internal_err;
                }
-       } else if (readl(priv->catas_err.map)) {
+       } else if (read32(priv->catas_err.map)) {
                dump_err_buf(dev);
                goto internal_err;
        }
index 529ef05..9fa4ab4 100644 (file)
@@ -126,15 +126,15 @@ struct mlx4_cmd_context {
        struct completion       done;
        int                     result;
        int                     next;
-       u64                     out_param;
-       u16                     token;
-       u8                      fw_status;
+       uint64_t                        out_param;
+       uint16_t                        token;
+       uint8_t                 fw_status;
 };
 
 static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
                                    struct mlx4_vhcr_cmd *in_vhcr);
 
-static int mlx4_status_to_errno(u8 status)
+static int mlx4_status_to_errno(uint8_t status)
 {
        static const int trans_table[] = {
                [CMD_STAT_INTERNAL_ERR]   = -EIO,
@@ -164,7 +164,7 @@ static int mlx4_status_to_errno(u8 status)
        return trans_table[status];
 }
 
-static u8 mlx4_errno_to_status(int errno)
+static uint8_t mlx4_errno_to_status(int errno)
 {
        switch (errno) {
        case -EPERM:
@@ -184,8 +184,8 @@ static u8 mlx4_errno_to_status(int errno)
        }
 }
 
-static int mlx4_internal_err_ret_value(struct mlx4_dev *dev, u16 op,
-                                      u8 op_modifier)
+static int mlx4_internal_err_ret_value(struct mlx4_dev *dev, uint16_t op,
+                                      uint8_t op_modifier)
 {
        switch (op) {
        case MLX4_CMD_UNMAP_ICM:
@@ -213,7 +213,7 @@ static int mlx4_internal_err_ret_value(struct mlx4_dev *dev, u16 op,
        }
 }
 
-static int mlx4_closing_cmd_fatal_error(u16 op, u8 fw_status)
+static int mlx4_closing_cmd_fatal_error(uint16_t op, uint8_t fw_status)
 {
        /* Any error during the closing commands below is considered fatal */
        if (op == MLX4_CMD_CLOSE_HCA ||
@@ -236,7 +236,8 @@ static int mlx4_closing_cmd_fatal_error(u16 op, u8 fw_status)
        return 0;
 }
 
-static int mlx4_cmd_reset_flow(struct mlx4_dev *dev, u16 op, u8 op_modifier,
+static int mlx4_cmd_reset_flow(struct mlx4_dev *dev, uint16_t op,
+                              uint8_t op_modifier,
                               int err)
 {
        /* Only if reset flow is really active return code is based on
@@ -253,39 +254,41 @@ static int mlx4_cmd_reset_flow(struct mlx4_dev *dev, u16 op, u8 op_modifier,
 static int comm_pending(struct mlx4_dev *dev)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
-       u32 status = readl(&priv->mfunc.comm->slave_read);
+       uint32_t status = read32(&priv->mfunc.comm->slave_read);
 
        return (swab32(status) >> 31) != priv->cmd.comm_toggle;
 }
 
-static int mlx4_comm_cmd_post(struct mlx4_dev *dev, u8 cmd, u16 param)
+static int mlx4_comm_cmd_post(struct mlx4_dev *dev, uint8_t cmd,
+                             uint16_t param)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
-       u32 val;
+       uint32_t val;
 
        /* To avoid writing to unknown addresses after the device state was
         * changed to internal error and the function was rest,
         * check the INTERNAL_ERROR flag which is updated under
         * device_state_mutex lock.
         */
-       mutex_lock(&dev->persist->device_state_mutex);
+       qlock(&dev->persist->device_state_mutex);
 
        if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR) {
-               mutex_unlock(&dev->persist->device_state_mutex);
+               qunlock(&dev->persist->device_state_mutex);
                return -EIO;
        }
 
        priv->cmd.comm_toggle ^= 1;
        val = param | (cmd << 16) | (priv->cmd.comm_toggle << 31);
-       __raw_writel((__force u32) cpu_to_be32(val),
+       __raw_write32((__force uint32_t) cpu_to_be32(val),
                     &priv->mfunc.comm->slave_write);
-       mmiowb();
-       mutex_unlock(&dev->persist->device_state_mutex);
+       bus_wmb();
+       qunlock(&dev->persist->device_state_mutex);
        return 0;
 }
 
-static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, u8 cmd, u16 param,
-                      unsigned long timeout)
+static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, uint8_t cmd,
+                             uint16_t param,
+                             unsigned long timeout)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        unsigned long end;
@@ -334,8 +337,9 @@ out:
        return err;
 }
 
-static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, u8 vhcr_cmd,
-                             u16 param, u16 op, unsigned long timeout)
+static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, uint8_t vhcr_cmd,
+                             uint16_t param, uint16_t op,
+                             unsigned long timeout)
 {
        struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
        struct mlx4_cmd_context *context;
@@ -345,7 +349,7 @@ static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, u8 vhcr_cmd,
        down(&cmd->event_sem);
 
        spin_lock(&cmd->context_lock);
-       BUG_ON(cmd->free_head < 0);
+       assert(!(cmd->free_head < 0));
        context = &cmd->context[cmd->free_head];
        context->token += cmd->token_mask + 1;
        cmd->free_head = context->next;
@@ -403,8 +407,8 @@ out:
        return err;
 }
 
-int mlx4_comm_cmd(struct mlx4_dev *dev, u8 cmd, u16 param,
-                 u16 op, unsigned long timeout)
+int mlx4_comm_cmd(struct mlx4_dev *dev, uint8_t cmd, uint16_t param,
+                 uint16_t op, unsigned long timeout)
 {
        if (dev->persist->state & MLX4_DEVICE_STATE_INTERNAL_ERROR)
                return mlx4_status_to_errno(CMD_STAT_INTERNAL_ERR);
@@ -416,28 +420,31 @@ int mlx4_comm_cmd(struct mlx4_dev *dev, u8 cmd, u16 param,
 
 static int cmd_pending(struct mlx4_dev *dev)
 {
-       u32 status;
+       uint32_t status;
 
        if (pci_channel_offline(dev->persist->pdev))
                return -EIO;
 
-       status = readl(mlx4_priv(dev)->cmd.hcr + HCR_STATUS_OFFSET);
+       status = read32(mlx4_priv(dev)->cmd.hcr + HCR_STATUS_OFFSET);
 
        return (status & swab32(1 << HCR_GO_BIT)) ||
                (mlx4_priv(dev)->cmd.toggle ==
                 !!(status & swab32(1 << HCR_T_BIT)));
 }
 
-static int mlx4_cmd_post(struct mlx4_dev *dev, u64 in_param, u64 out_param,
-                        u32 in_modifier, u8 op_modifier, u16 op, u16 token,
+static int mlx4_cmd_post(struct mlx4_dev *dev, uint64_t in_param,
+                        uint64_t out_param,
+                        uint32_t in_modifier, uint8_t op_modifier,
+                        uint16_t op,
+                        uint16_t token,
                         int event)
 {
        struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
-       u32 __iomem *hcr = cmd->hcr;
+       uint32_t __iomem *hcr = cmd->hcr;
        int ret = -EIO;
        unsigned long end;
 
-       mutex_lock(&dev->persist->device_state_mutex);
+       qlock(&dev->persist->device_state_mutex);
        /* To avoid writing to unknown addresses after the device state was
          * changed to internal error and the chip was reset,
          * check the INTERNAL_ERROR flag which is updated under
@@ -478,27 +485,33 @@ static int mlx4_cmd_post(struct mlx4_dev *dev, u64 in_param, u64 out_param,
         * (and some architectures such as ia64 implement memcpy_toio
         * in terms of writeb).
         */
-       __raw_writel((__force u32) cpu_to_be32(in_param >> 32),           hcr + 0);
-       __raw_writel((__force u32) cpu_to_be32(in_param & 0xfffffffful),  hcr + 1);
-       __raw_writel((__force u32) cpu_to_be32(in_modifier),              hcr + 2);
-       __raw_writel((__force u32) cpu_to_be32(out_param >> 32),          hcr + 3);
-       __raw_writel((__force u32) cpu_to_be32(out_param & 0xfffffffful), hcr + 4);
-       __raw_writel((__force u32) cpu_to_be32(token << 16),              hcr + 5);
+       __raw_write32((__force uint32_t) cpu_to_be32(in_param >> 32),
+                     hcr + 0);
+       __raw_write32((__force uint32_t) cpu_to_be32(in_param & 0xfffffffful),
+                     hcr + 1);
+       __raw_write32((__force uint32_t) cpu_to_be32(in_modifier),
+                     hcr + 2);
+       __raw_write32((__force uint32_t) cpu_to_be32(out_param >> 32),
+                     hcr + 3);
+       __raw_write32((__force uint32_t) cpu_to_be32(out_param & 0xfffffffful),
+                     hcr + 4);
+       __raw_write32((__force uint32_t) cpu_to_be32(token << 16),
+                     hcr + 5);
 
        /* __raw_writel may not order writes. */
        wmb();
 
-       __raw_writel((__force u32) cpu_to_be32((1 << HCR_GO_BIT)                |
-                                              (cmd->toggle << HCR_T_BIT)       |
-                                              (event ? (1 << HCR_E_BIT) : 0)   |
-                                              (op_modifier << HCR_OPMOD_SHIFT) |
-                                              op), hcr + 6);
+       __raw_write32((__force uint32_t) cpu_to_be32((1 << HCR_GO_BIT)          |
+                                                   (cmd->toggle << HCR_T_BIT)  |
+                                                   (event ? (1 << HCR_E_BIT) : 0)      |
+                                                   (op_modifier << HCR_OPMOD_SHIFT) |
+                                                   op), hcr + 6);
 
        /*
         * Make sure that our HCR writes don't get mixed in with
         * writes from another CPU starting a FW command.
         */
-       mmiowb();
+       bus_wmb();
 
        cmd->toggle = cmd->toggle ^ 1;
 
@@ -508,25 +521,27 @@ out:
        if (ret)
                mlx4_warn(dev, "Could not post command 0x%x: ret=%d, in_param=0x%llx, in_mod=0x%x, op_mod=0x%x\n",
                          op, ret, in_param, in_modifier, op_modifier);
-       mutex_unlock(&dev->persist->device_state_mutex);
+       qunlock(&dev->persist->device_state_mutex);
 
        return ret;
 }
 
-static int mlx4_slave_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
-                         int out_is_imm, u32 in_modifier, u8 op_modifier,
-                         u16 op, unsigned long timeout)
+static int mlx4_slave_cmd(struct mlx4_dev *dev, uint64_t in_param,
+                         uint64_t *out_param,
+                         int out_is_imm, uint32_t in_modifier,
+                         uint8_t op_modifier,
+                         uint16_t op, unsigned long timeout)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_vhcr_cmd *vhcr = priv->mfunc.vhcr;
        int ret;
 
-       mutex_lock(&priv->cmd.slave_cmd_mutex);
+       qlock(&priv->cmd.slave_cmd_mutex);
 
        vhcr->in_param = cpu_to_be64(in_param);
        vhcr->out_param = out_param ? cpu_to_be64(*out_param) : 0;
        vhcr->in_modifier = cpu_to_be32(in_modifier);
-       vhcr->opcode = cpu_to_be16((((u16) op_modifier) << 12) | (op & 0xfff));
+       vhcr->opcode = cpu_to_be16((((uint16_t) op_modifier) << 12) | (op & 0xfff));
        vhcr->token = cpu_to_be16(CMD_POLL_TOKEN);
        vhcr->status = 0;
        vhcr->flags = !!(priv->cmd.use_events) << 6;
@@ -574,19 +589,21 @@ static int mlx4_slave_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
                }
        }
 
-       mutex_unlock(&priv->cmd.slave_cmd_mutex);
+       qunlock(&priv->cmd.slave_cmd_mutex);
        return ret;
 }
 
-static int mlx4_cmd_poll(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
-                        int out_is_imm, u32 in_modifier, u8 op_modifier,
-                        u16 op, unsigned long timeout)
+static int mlx4_cmd_poll(struct mlx4_dev *dev, uint64_t in_param,
+                        uint64_t *out_param,
+                        int out_is_imm, uint32_t in_modifier,
+                        uint8_t op_modifier,
+                        uint16_t op, unsigned long timeout)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        void __iomem *hcr = priv->cmd.hcr;
        int err = 0;
        unsigned long end;
-       u32 stat;
+       uint32_t stat;
 
        down(&priv->cmd.poll_sem);
 
@@ -639,12 +656,12 @@ static int mlx4_cmd_poll(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
 
        if (out_is_imm)
                *out_param =
-                       (u64) be32_to_cpu((__force __be32)
-                                         __raw_readl(hcr + HCR_OUT_PARAM_OFFSET)) << 32 |
-                       (u64) be32_to_cpu((__force __be32)
-                                         __raw_readl(hcr + HCR_OUT_PARAM_OFFSET + 4));
+                       (uint64_t) be32_to_cpu((__force __be32)
+                                         __raw_read32(hcr + HCR_OUT_PARAM_OFFSET)) << 32 |
+                       (uint64_t) be32_to_cpu((__force __be32)
+                                         __raw_read32(hcr + HCR_OUT_PARAM_OFFSET + 4));
        stat = be32_to_cpu((__force __be32)
-                          __raw_readl(hcr + HCR_STATUS_OFFSET)) >> 24;
+                          __raw_read32(hcr + HCR_STATUS_OFFSET)) >> 24;
        err = mlx4_status_to_errno(stat);
        if (err) {
                mlx4_err(dev, "command 0x%x failed: fw status = 0x%x\n",
@@ -662,7 +679,8 @@ out:
        return err;
 }
 
-void mlx4_cmd_event(struct mlx4_dev *dev, u16 token, u8 status, u64 out_param)
+void mlx4_cmd_event(struct mlx4_dev *dev, uint16_t token, uint8_t status,
+                   uint64_t out_param)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_cmd_context *context =
@@ -679,9 +697,11 @@ void mlx4_cmd_event(struct mlx4_dev *dev, u16 token, u8 status, u64 out_param)
        complete(&context->done);
 }
 
-static int mlx4_cmd_wait(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
-                        int out_is_imm, u32 in_modifier, u8 op_modifier,
-                        u16 op, unsigned long timeout)
+static int mlx4_cmd_wait(struct mlx4_dev *dev, uint64_t in_param,
+                        uint64_t *out_param,
+                        int out_is_imm, uint32_t in_modifier,
+                        uint8_t op_modifier,
+                        uint16_t op, unsigned long timeout)
 {
        struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
        struct mlx4_cmd_context *context;
@@ -690,7 +710,7 @@ static int mlx4_cmd_wait(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
        down(&cmd->event_sem);
 
        spin_lock(&cmd->context_lock);
-       BUG_ON(cmd->free_head < 0);
+       assert(!(cmd->free_head < 0));
        context = &cmd->context[cmd->free_head];
        context->token += cmd->token_mask + 1;
        cmd->free_head = context->next;
@@ -763,9 +783,9 @@ out:
        return err;
 }
 
-int __mlx4_cmd(struct mlx4_dev *dev, u64 in_param, u64 *out_param,
-              int out_is_imm, u32 in_modifier, u8 op_modifier,
-              u16 op, unsigned long timeout, int native)
+int __mlx4_cmd(struct mlx4_dev *dev, uint64_t in_param, uint64_t *out_param,
+              int out_is_imm, uint32_t in_modifier, uint8_t op_modifier,
+              uint16_t op, unsigned long timeout, int native)
 {
        if (pci_channel_offline(dev->persist->pdev))
                return mlx4_cmd_reset_flow(dev, op, op_modifier, -EIO);
@@ -795,12 +815,12 @@ int mlx4_ARM_COMM_CHANNEL(struct mlx4_dev *dev)
                        MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
 }
 
-static int mlx4_ACCESS_MEM(struct mlx4_dev *dev, u64 master_addr,
-                          int slave, u64 slave_addr,
+static int mlx4_ACCESS_MEM(struct mlx4_dev *dev, uint64_t master_addr,
+                          int slave, uint64_t slave_addr,
                           int size, int is_read)
 {
-       u64 in_param;
-       u64 out_param;
+       uint64_t in_param;
+       uint64_t out_param;
 
        if ((slave_addr & 0xfff) | (master_addr & 0xfff) |
            (slave & ~0x7f) | (size & 0xff)) {
@@ -810,11 +830,11 @@ static int mlx4_ACCESS_MEM(struct mlx4_dev *dev, u64 master_addr,
        }
 
        if (is_read) {
-               in_param = (u64) slave | slave_addr;
-               out_param = (u64) dev->caps.function | master_addr;
+               in_param = (uint64_t) slave | slave_addr;
+               out_param = (uint64_t) dev->caps.function | master_addr;
        } else {
-               in_param = (u64) dev->caps.function | master_addr;
-               out_param = (u64) slave | slave_addr;
+               in_param = (uint64_t) dev->caps.function | master_addr;
+               out_param = (uint64_t) slave | slave_addr;
        }
 
        return mlx4_cmd_imm(dev, in_param, &out_param, size, 0,
@@ -822,7 +842,9 @@ static int mlx4_ACCESS_MEM(struct mlx4_dev *dev, u64 master_addr,
                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 }
 
-static int query_pkey_block(struct mlx4_dev *dev, u8 port, u16 index, u16 *pkey,
+static int query_pkey_block(struct mlx4_dev *dev, uint8_t port,
+                              uint16_t index,
+                              uint16_t *pkey,
                               struct mlx4_cmd_mailbox *inbox,
                               struct mlx4_cmd_mailbox *outbox)
 {
@@ -848,7 +870,8 @@ static int query_pkey_block(struct mlx4_dev *dev, u8 port, u16 index, u16 *pkey,
        return err;
 }
 
-static int get_full_pkey_table(struct mlx4_dev *dev, u8 port, u16 *table,
+static int get_full_pkey_table(struct mlx4_dev *dev, uint8_t port,
+                              uint16_t *table,
                               struct mlx4_cmd_mailbox *inbox,
                               struct mlx4_cmd_mailbox *outbox)
 {
@@ -881,10 +904,10 @@ static int mlx4_MAD_IFC_wrapper(struct mlx4_dev *dev, int slave,
                                struct mlx4_cmd_info *cmd)
 {
        struct ib_smp *smp = inbox->buf;
-       u32 index;
-       u8 port;
-       u8 opcode_modifier;
-       u16 *table;
+       uint32_t index;
+       uint8_t port;
+       uint8_t opcode_modifier;
+       uint16_t *table;
        int err;
        int vidx, pidx;
        int network_view;
@@ -909,8 +932,8 @@ static int mlx4_MAD_IFC_wrapper(struct mlx4_dev *dev, int slave,
                                index = be32_to_cpu(smp->attr_mod);
                                if (port < 1 || port > dev->caps.num_ports)
                                        return -EINVAL;
-                               table = kcalloc((dev->caps.pkey_table_len[port] / 32) + 1,
-                                               sizeof(*table) * 32, GFP_KERNEL);
+                               table = kzmalloc(((dev->caps.pkey_table_len[port] / 32) + 1) * (sizeof(*table) * 32),
+                                                KMALLOC_WAIT);
 
                                if (!table)
                                        return -ENOMEM;
@@ -935,7 +958,7 @@ static int mlx4_MAD_IFC_wrapper(struct mlx4_dev *dev, int slave,
                                            vhcr->op, MLX4_CMD_TIME_CLASS_C, MLX4_CMD_NATIVE);
                                /* modify the response for slaves */
                                if (!err && slave != mlx4_master_func_num(dev)) {
-                                       u8 *state = outsmp->data + PORT_STATE_OFFSET;
+                                       uint8_t *state = outsmp->data + PORT_STATE_OFFSET;
 
                                        *state = (*state & 0xf0) | vf_port_state(dev, port, slave);
                                        slave_cap_mask = priv->mfunc.master.slave_state[slave].ib_cap_mask[port];
@@ -1021,12 +1044,12 @@ int mlx4_DMA_wrapper(struct mlx4_dev *dev, int slave,
                     struct mlx4_cmd_mailbox *outbox,
                     struct mlx4_cmd_info *cmd)
 {
-       u64 in_param;
-       u64 out_param;
+       uint64_t in_param;
+       uint64_t out_param;
        int err;
 
-       in_param = cmd->has_inbox ? (u64) inbox->dma : vhcr->in_param;
-       out_param = cmd->has_outbox ? (u64) outbox->dma : vhcr->out_param;
+       in_param = cmd->has_inbox ? (uint64_t) inbox->dma : vhcr->in_param;
+       out_param = cmd->has_outbox ? (uint64_t) outbox->dma : vhcr->out_param;
        if (cmd->encode_slave_id) {
                in_param &= 0xffffffffffffff00ll;
                in_param |= slave;
@@ -1651,14 +1674,14 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
        struct mlx4_vhcr *vhcr;
        struct mlx4_cmd_mailbox *inbox = NULL;
        struct mlx4_cmd_mailbox *outbox = NULL;
-       u64 in_param;
-       u64 out_param;
+       uint64_t in_param;
+       uint64_t out_param;
        int ret = 0;
        int i;
        int err = 0;
 
        /* Create sw representation of Virtual HCR */
-       vhcr = kzalloc(sizeof(struct mlx4_vhcr), GFP_KERNEL);
+       vhcr = kzmalloc(sizeof(struct mlx4_vhcr), KMALLOC_WAIT);
        if (!vhcr)
                return -ENOMEM;
 
@@ -1684,7 +1707,7 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
        vhcr->in_modifier = be32_to_cpu(vhcr_cmd->in_modifier);
        vhcr->token = be16_to_cpu(vhcr_cmd->token);
        vhcr->op = be16_to_cpu(vhcr_cmd->opcode) & 0xfff;
-       vhcr->op_modifier = (u8) (be16_to_cpu(vhcr_cmd->opcode) >> 12);
+       vhcr->op_modifier = (uint8_t) (be16_to_cpu(vhcr_cmd->opcode) >> 12);
        vhcr->e_bit = vhcr_cmd->flags & (1 << 6);
 
        /* Lookup command */
@@ -1749,9 +1772,9 @@ static int mlx4_master_process_vhcr(struct mlx4_dev *dev, int slave,
                if (cmd->out_is_imm)
                        vhcr_cmd->out_param = cpu_to_be64(vhcr->out_param);
        } else {
-               in_param = cmd->has_inbox ? (u64) inbox->dma :
+               in_param = cmd->has_inbox ? (uint64_t) inbox->dma :
                        vhcr->in_param;
-               out_param = cmd->has_outbox ? (u64) outbox->dma :
+               out_param = cmd->has_outbox ? (uint64_t) outbox->dma :
                        vhcr->out_param;
                err = __mlx4_cmd(dev, in_param, &out_param,
                                 cmd->out_is_imm, vhcr->in_modifier,
@@ -1848,7 +1871,7 @@ static int mlx4_master_immediate_activate_vlan_qos(struct mlx4_priv *priv,
                 vp_admin->default_vlan, vp_admin->default_qos,
                 vp_admin->link_state);
 
-       work = kzalloc(sizeof(*work), GFP_KERNEL);
+       work = kzmalloc(sizeof(*work), KMALLOC_WAIT);
        if (!work)
                return -ENOMEM;
 
@@ -1924,8 +1947,8 @@ static void mlx4_allocate_port_vpps(struct mlx4_dev *dev, int port)
        int i;
        int err;
        int num_vfs;
-       u16 availible_vpp;
-       u8 vpp_param[MLX4_NUM_UP];
+       uint16_t availible_vpp;
+       uint8_t vpp_param[MLX4_NUM_UP];
        struct mlx4_qos_manager *port_qos;
        struct mlx4_priv *priv = mlx4_priv(dev);
 
@@ -2049,18 +2072,18 @@ static void mlx4_master_deactivate_admin_state(struct mlx4_priv *priv, int slave
        return;
 }
 
-static void mlx4_master_do_cmd(struct mlx4_dev *dev, int slave, u8 cmd,
-                              u16 param, u8 toggle)
+static void mlx4_master_do_cmd(struct mlx4_dev *dev, int slave, uint8_t cmd,
+                              uint16_t param, uint8_t toggle)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_slave_state *slave_state = priv->mfunc.master.slave_state;
-       u32 reply;
-       u8 is_going_down = 0;
+       uint32_t reply;
+       uint8_t is_going_down = 0;
        int i;
        unsigned long flags;
 
        slave_state[slave].comm_toggle ^= 1;
-       reply = (u32) slave_state[slave].comm_toggle << 31;
+       reply = (uint32_t) slave_state[slave].comm_toggle << 31;
        if (toggle != slave_state[slave].comm_toggle) {
                mlx4_warn(dev, "Incorrect toggle %d from slave %d. *** MASTER STATE COMPROMISED ***\n",
                          toggle, slave);
@@ -2099,18 +2122,18 @@ static void mlx4_master_do_cmd(struct mlx4_dev *dev, int slave, u8 cmd,
        case MLX4_COMM_CMD_VHCR0:
                if (slave_state[slave].last_cmd != MLX4_COMM_CMD_RESET)
                        goto reset_slave;
-               slave_state[slave].vhcr_dma = ((u64) param) << 48;
+               slave_state[slave].vhcr_dma = ((uint64_t) param) << 48;
                priv->mfunc.master.slave_state[slave].cookie = 0;
                break;
        case MLX4_COMM_CMD_VHCR1:
                if (slave_state[slave].last_cmd != MLX4_COMM_CMD_VHCR0)
                        goto reset_slave;
-               slave_state[slave].vhcr_dma |= ((u64) param) << 32;
+               slave_state[slave].vhcr_dma |= ((uint64_t) param) << 32;
                break;
        case MLX4_COMM_CMD_VHCR2:
                if (slave_state[slave].last_cmd != MLX4_COMM_CMD_VHCR1)
                        goto reset_slave;
-               slave_state[slave].vhcr_dma |= ((u64) param) << 16;
+               slave_state[slave].vhcr_dma |= ((uint64_t) param) << 16;
                break;
        case MLX4_COMM_CMD_VHCR_EN:
                if (slave_state[slave].last_cmd != MLX4_COMM_CMD_VHCR2)
@@ -2129,33 +2152,33 @@ static void mlx4_master_do_cmd(struct mlx4_dev *dev, int slave, u8 cmd,
                        goto reset_slave;
                }
 
-               mutex_lock(&priv->cmd.slave_cmd_mutex);
+               qlock(&priv->cmd.slave_cmd_mutex);
                if (mlx4_master_process_vhcr(dev, slave, NULL)) {
                        mlx4_err(dev, "Failed processing vhcr for slave:%d, resetting slave\n",
                                 slave);
-                       mutex_unlock(&priv->cmd.slave_cmd_mutex);
+                       qunlock(&priv->cmd.slave_cmd_mutex);
                        goto reset_slave;
                }
-               mutex_unlock(&priv->cmd.slave_cmd_mutex);
+               qunlock(&priv->cmd.slave_cmd_mutex);
                break;
        default:
                mlx4_warn(dev, "Bad comm cmd:%d from slave:%d\n", cmd, slave);
                goto reset_slave;
        }
-       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock, flags);
+       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock);
        if (!slave_state[slave].is_slave_going_down)
                slave_state[slave].last_cmd = cmd;
        else
                is_going_down = 1;
-       spin_unlock_irqrestore(&priv->mfunc.master.slave_state_lock, flags);
+       spin_unlock_irqsave(&priv->mfunc.master.slave_state_lock);
        if (is_going_down) {
                mlx4_warn(dev, "Slave is going down aborting command(%d) executing from slave:%d\n",
                          cmd, slave);
                return;
        }
-       __raw_writel((__force u32) cpu_to_be32(reply),
+       __raw_write32((__force uint32_t) cpu_to_be32(reply),
                     &priv->mfunc.comm[slave].slave_read);
-       mmiowb();
+       bus_wmb();
 
        return;
 
@@ -2170,18 +2193,18 @@ reset_slave:
                /* Turn on internal error letting slave reset itself immeditaly,
                 * otherwise it might take till timeout on command is passed
                 */
-               reply |= ((u32)COMM_CHAN_EVENT_INTERNAL_ERR);
+               reply |= ((uint32_t)COMM_CHAN_EVENT_INTERNAL_ERR);
        }
 
-       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock, flags);
+       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock);
        if (!slave_state[slave].is_slave_going_down)
                slave_state[slave].last_cmd = MLX4_COMM_CMD_RESET;
-       spin_unlock_irqrestore(&priv->mfunc.master.slave_state_lock, flags);
+       spin_unlock_irqsave(&priv->mfunc.master.slave_state_lock);
        /*with slave in the middle of flr, no need to clean resources again.*/
 inform_slave_state:
        memset(&slave_state[slave].event_eq, 0,
               sizeof(struct mlx4_slave_event_eq_info));
-       __raw_writel((__force u32) cpu_to_be32(reply),
+       __raw_write32((__force uint32_t) cpu_to_be32(reply),
                     &priv->mfunc.comm[slave].slave_read);
        wmb();
 }
@@ -2199,13 +2222,13 @@ void mlx4_master_comm_channel(struct work_struct *work)
                container_of(mfunc, struct mlx4_priv, mfunc);
        struct mlx4_dev *dev = &priv->dev;
        __be32 *bit_vec;
-       u32 comm_cmd;
-       u32 vec;
+       uint32_t comm_cmd;
+       uint32_t vec;
        int i, j, slave;
        int toggle;
        int served = 0;
        int reported = 0;
-       u32 slt;
+       uint32_t slt;
 
        bit_vec = master->comm_arm_bit_vector;
        for (i = 0; i < COMM_CHANNEL_BIT_ARRAY_SIZE; i++) {
@@ -2215,9 +2238,9 @@ void mlx4_master_comm_channel(struct work_struct *work)
                                continue;
                        ++reported;
                        slave = (i * 32) + j;
-                       comm_cmd = swab32(readl(
-                                         &mfunc->comm[slave].slave_write));
-                       slt = swab32(readl(&mfunc->comm[slave].slave_read))
+                       comm_cmd = swab32(read32(
+                                                &mfunc->comm[slave].slave_write));
+                       slt = swab32(read32(&mfunc->comm[slave].slave_read))
                                     >> 31;
                        toggle = comm_cmd >> 31;
                        if (toggle != slt) {
@@ -2248,23 +2271,23 @@ void mlx4_master_comm_channel(struct work_struct *work)
 static int sync_toggles(struct mlx4_dev *dev)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
-       u32 wr_toggle;
-       u32 rd_toggle;
+       uint32_t wr_toggle;
+       uint32_t rd_toggle;
        unsigned long end;
 
-       wr_toggle = swab32(readl(&priv->mfunc.comm->slave_write));
+       wr_toggle = swab32(read32(&priv->mfunc.comm->slave_write));
        if (wr_toggle == 0xffffffff)
                end = jiffies + msecs_to_jiffies(30000);
        else
                end = jiffies + msecs_to_jiffies(5000);
 
        while (time_before(jiffies, end)) {
-               rd_toggle = swab32(readl(&priv->mfunc.comm->slave_read));
+               rd_toggle = swab32(read32(&priv->mfunc.comm->slave_read));
                if (wr_toggle == 0xffffffff || rd_toggle == 0xffffffff) {
                        /* PCI might be offline */
-                       msleep(100);
-                       wr_toggle = swab32(readl(&priv->mfunc.comm->
-                                          slave_write));
+                       kthread_usleep(1000 * 100);
+                       wr_toggle = swab32(read32(&priv->mfunc.comm->
+                                                 slave_write));
                        continue;
                }
 
@@ -2283,8 +2306,8 @@ static int sync_toggles(struct mlx4_dev *dev)
         * synced channel
         */
        mlx4_warn(dev, "recovering from previously mis-behaved VM\n");
-       __raw_writel((__force u32) 0, &priv->mfunc.comm->slave_read);
-       __raw_writel((__force u32) 0, &priv->mfunc.comm->slave_write);
+       __raw_write32((__force uint32_t) 0, &priv->mfunc.comm->slave_read);
+       __raw_write32((__force uint32_t) 0, &priv->mfunc.comm->slave_write);
        priv->cmd.comm_toggle = 0;
 
        return 0;
@@ -2315,20 +2338,20 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
                struct mlx4_vf_admin_state *vf_admin;
 
                priv->mfunc.master.slave_state =
-                       kzalloc(dev->num_slaves *
-                               sizeof(struct mlx4_slave_state), GFP_KERNEL);
+                       kzmalloc(dev->num_slaves * sizeof(struct mlx4_slave_state),
+                                KMALLOC_WAIT);
                if (!priv->mfunc.master.slave_state)
                        goto err_comm;
 
                priv->mfunc.master.vf_admin =
-                       kzalloc(dev->num_slaves *
-                               sizeof(struct mlx4_vf_admin_state), GFP_KERNEL);
+                       kzmalloc(dev->num_slaves * sizeof(struct mlx4_vf_admin_state),
+                                KMALLOC_WAIT);
                if (!priv->mfunc.master.vf_admin)
                        goto err_comm_admin;
 
                priv->mfunc.master.vf_oper =
-                       kzalloc(dev->num_slaves *
-                               sizeof(struct mlx4_vf_oper_state), GFP_KERNEL);
+                       kzmalloc(dev->num_slaves * sizeof(struct mlx4_vf_oper_state),
+                                KMALLOC_WAIT);
                if (!priv->mfunc.master.vf_oper)
                        goto err_comm_oper;
 
@@ -2337,21 +2360,21 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
                        vf_oper = &priv->mfunc.master.vf_oper[i];
                        s_state = &priv->mfunc.master.slave_state[i];
                        s_state->last_cmd = MLX4_COMM_CMD_RESET;
-                       mutex_init(&priv->mfunc.master.gen_eqe_mutex[i]);
+                       qlock_init(&priv->mfunc.master.gen_eqe_mutex[i]);
                        for (j = 0; j < MLX4_EVENT_TYPES_NUM; ++j)
                                s_state->event_eq[j].eqn = -1;
-                       __raw_writel((__force u32) 0,
+                       __raw_write32((__force uint32_t) 0,
                                     &priv->mfunc.comm[i].slave_write);
-                       __raw_writel((__force u32) 0,
+                       __raw_write32((__force uint32_t) 0,
                                     &priv->mfunc.comm[i].slave_read);
-                       mmiowb();
+                       bus_wmb();
                        for (port = 1; port <= MLX4_MAX_PORTS; port++) {
                                struct mlx4_vport_state *admin_vport;
                                struct mlx4_vport_state *oper_vport;
 
                                s_state->vlan_filter[port] =
-                                       kzalloc(sizeof(struct mlx4_vlan_fltr),
-                                               GFP_KERNEL);
+                                       kzmalloc(sizeof(struct mlx4_vlan_fltr),
+                                                KMALLOC_WAIT);
                                if (!s_state->vlan_filter[port]) {
                                        if (--port)
                                                kfree(s_state->vlan_filter[port]);
@@ -2370,7 +2393,7 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
                                vf_oper->vport[port].mac_idx = NO_INDX;
                                mlx4_set_random_admin_guid(dev, i, port);
                        }
-                       spin_lock_init(&s_state->lock);
+                       spinlock_init_irqsave(&s_state->lock);
                }
 
                if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_QOS_VPP) {
@@ -2390,8 +2413,8 @@ int mlx4_multi_func_init(struct mlx4_dev *dev)
                          mlx4_gen_slave_eqe);
                INIT_WORK(&priv->mfunc.master.slave_flr_event_work,
                          mlx4_master_handle_slave_flr);
-               spin_lock_init(&priv->mfunc.master.slave_state_lock);
-               spin_lock_init(&priv->mfunc.master.slave_eq.event_lock);
+               spinlock_init_irqsave(&priv->mfunc.master.slave_state_lock);
+               spinlock_init_irqsave(&priv->mfunc.master.slave_eq.event_lock);
                priv->mfunc.master.comm_wq =
                        create_singlethread_workqueue("mlx4_comm");
                if (!priv->mfunc.master.comm_wq)
@@ -2438,7 +2461,7 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
        int flags = 0;
 
        if (!priv->cmd.initialized) {
-               mutex_init(&priv->cmd.slave_cmd_mutex);
+               qlock_init(&priv->cmd.slave_cmd_mutex);
                sema_init(&priv->cmd.poll_sem, 1);
                priv->cmd.use_events = 0;
                priv->cmd.toggle     = 1;
@@ -2460,7 +2483,7 @@ int mlx4_cmd_init(struct mlx4_dev *dev)
                priv->mfunc.vhcr = dma_alloc_coherent(&dev->persist->pdev->dev,
                                                      PAGE_SIZE,
                                                      &priv->mfunc.vhcr_dma,
-                                                     GFP_KERNEL);
+                                                     KMALLOC_WAIT);
                if (!priv->mfunc.vhcr)
                        goto err;
 
@@ -2489,20 +2512,20 @@ void mlx4_report_internal_err_comm_event(struct mlx4_dev *dev)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        int slave;
-       u32 slave_read;
+       uint32_t slave_read;
 
        /* Report an internal error event to all
         * communication channels.
         */
        for (slave = 0; slave < dev->num_slaves; slave++) {
-               slave_read = swab32(readl(&priv->mfunc.comm[slave].slave_read));
-               slave_read |= (u32)COMM_CHAN_EVENT_INTERNAL_ERR;
-               __raw_writel((__force u32)cpu_to_be32(slave_read),
+               slave_read = swab32(read32(&priv->mfunc.comm[slave].slave_read));
+               slave_read |= (uint32_t)COMM_CHAN_EVENT_INTERNAL_ERR;
+               __raw_write32((__force uint32_t)cpu_to_be32(slave_read),
                             &priv->mfunc.comm[slave].slave_read);
                /* Make sure that our comm channel write doesn't
                 * get mixed in with writes from another CPU.
                 */
-               mmiowb();
+               bus_wmb();
        }
 }
 
@@ -2563,7 +2586,7 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
 
        priv->cmd.context = kmalloc(priv->cmd.max_cmds *
                                   sizeof (struct mlx4_cmd_context),
-                                  GFP_KERNEL);
+                                  KMALLOC_WAIT);
        if (!priv->cmd.context)
                return -ENOMEM;
 
@@ -2581,7 +2604,7 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
        priv->cmd.free_head = 0;
 
        sema_init(&priv->cmd.event_sem, priv->cmd.max_cmds);
-       spin_lock_init(&priv->cmd.context_lock);
+       spinlock_init_irqsave(&priv->cmd.context_lock);
 
        for (priv->cmd.token_mask = 1;
             priv->cmd.token_mask < priv->cmd.max_cmds;
@@ -2617,11 +2640,11 @@ struct mlx4_cmd_mailbox *mlx4_alloc_cmd_mailbox(struct mlx4_dev *dev)
 {
        struct mlx4_cmd_mailbox *mailbox;
 
-       mailbox = kmalloc(sizeof *mailbox, GFP_KERNEL);
+       mailbox = kmalloc(sizeof *mailbox, KMALLOC_WAIT);
        if (!mailbox)
                return ERR_PTR(-ENOMEM);
 
-       mailbox->buf = pci_pool_alloc(mlx4_priv(dev)->cmd.pool, GFP_KERNEL,
+       mailbox->buf = pci_pool_alloc(mlx4_priv(dev)->cmd.pool, KMALLOC_WAIT,
                                      &mailbox->dma);
        if (!mailbox->buf) {
                kfree(mailbox);
@@ -2645,9 +2668,9 @@ void mlx4_free_cmd_mailbox(struct mlx4_dev *dev,
 }
 EXPORT_SYMBOL_GPL(mlx4_free_cmd_mailbox);
 
-u32 mlx4_comm_get_version(void)
+uint32_t mlx4_comm_get_version(void)
 {
-        return ((u32) CMD_CHAN_IF_REV << 8) | (u32) CMD_CHAN_VER;
+        return ((uint32_t) CMD_CHAN_IF_REV << 8) | (uint32_t) CMD_CHAN_VER;
 }
 
 static int mlx4_get_slave_indx(struct mlx4_dev *dev, int vf)
@@ -2708,8 +2731,7 @@ struct mlx4_active_ports mlx4_get_active_ports(struct mlx4_dev *dev, int slave)
                return actv_ports;
 
        bitmap_set(actv_ports.ports, dev->dev_vfs[vf].min_port - 1,
-                  min((int)dev->dev_vfs[mlx4_get_vf_indx(dev, slave)].n_ports,
-                  dev->caps.num_ports));
+                  MIN((int)dev->dev_vfs[mlx4_get_vf_indx(dev, slave)].n_ports, dev->caps.num_ports));
 
        return actv_ports;
 }
@@ -2899,7 +2921,7 @@ static bool mlx4_valid_vf_state_change(struct mlx4_dev *dev, int port,
        return false;
 }
 
-int mlx4_set_vf_mac(struct mlx4_dev *dev, int port, int vf, u64 mac)
+int mlx4_set_vf_mac(struct mlx4_dev *dev, int port, int vf, uint64_t mac)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_vport_state *s_info;
@@ -2922,7 +2944,8 @@ int mlx4_set_vf_mac(struct mlx4_dev *dev, int port, int vf, u64 mac)
 EXPORT_SYMBOL_GPL(mlx4_set_vf_mac);
 
 
-int mlx4_set_vf_vlan(struct mlx4_dev *dev, int port, int vf, u16 vlan, u8 qos)
+int mlx4_set_vf_vlan(struct mlx4_dev *dev, int port, int vf, uint16_t vlan,
+                    uint8_t qos)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_vport_state *vf_admin;
@@ -3034,7 +3057,7 @@ EXPORT_SYMBOL_GPL(mlx4_set_vf_rate);
  * if VST, will return vlan & qos (if not NULL)
  */
 bool mlx4_get_slave_default_vlan(struct mlx4_dev *dev, int port, int slave,
-                                u16 *vlan, u8 *qos)
+                                uint16_t *vlan, uint8_t *qos)
 {
        struct mlx4_vport_oper_state *vp_oper;
        struct mlx4_priv *priv;
@@ -3121,7 +3144,7 @@ int mlx4_set_vf_link_state(struct mlx4_dev *dev, int port, int vf, int link_stat
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_vport_state *s_info;
        int slave;
-       u8 link_stat_event;
+       uint8_t link_stat_event;
 
        slave = mlx4_get_slave_indx(dev, vf);
        if (slave < 0)
index e71f313..4b6f6b9 100644 (file)
@@ -62,14 +62,14 @@ void mlx4_cq_tasklet_cb(unsigned long data)
        struct mlx4_eq_tasklet *ctx = (struct mlx4_eq_tasklet *)data;
        struct mlx4_cq *mcq, *temp;
 
-       spin_lock_irqsave(&ctx->lock, flags);
+       spin_lock_irqsave(&ctx->lock);
        list_splice_tail_init(&ctx->list, &ctx->process_list);
-       spin_unlock_irqrestore(&ctx->lock, flags);
+       spin_unlock_irqsave(&ctx->lock);
 
        list_for_each_entry_safe(mcq, temp, &ctx->process_list, tasklet_ctx.list) {
                list_del_init(&mcq->tasklet_ctx.list);
                mcq->tasklet_ctx.comp(mcq);
-               if (atomic_dec_and_test(&mcq->refcount))
+               if (atomic_sub_and_test(&mcq->refcount, 1))
                        complete(&mcq->free);
                if (time_after(jiffies, end))
                        break;
@@ -84,7 +84,7 @@ static void mlx4_add_cq_to_tasklet(struct mlx4_cq *cq)
        unsigned long flags;
        struct mlx4_eq_tasklet *tasklet_ctx = cq->tasklet_ctx.priv;
 
-       spin_lock_irqsave(&tasklet_ctx->lock, flags);
+       spin_lock_irqsave(&tasklet_ctx->lock);
        /* When migrating CQs between EQs will be implemented, please note
         * that you need to sync this point. It is possible that
         * while migrating a CQ, completions on the old EQs could
@@ -94,10 +94,10 @@ static void mlx4_add_cq_to_tasklet(struct mlx4_cq *cq)
                atomic_inc(&cq->refcount);
                list_add_tail(&cq->tasklet_ctx.list, &tasklet_ctx->list);
        }
-       spin_unlock_irqrestore(&tasklet_ctx->lock, flags);
+       spin_unlock_irqsave(&tasklet_ctx->lock);
 }
 
-void mlx4_cq_completion(struct mlx4_dev *dev, u32 cqn)
+void mlx4_cq_completion(struct mlx4_dev *dev, uint32_t cqn)
 {
        struct mlx4_cq *cq;
 
@@ -113,7 +113,7 @@ void mlx4_cq_completion(struct mlx4_dev *dev, u32 cqn)
        cq->comp(cq);
 }
 
-void mlx4_cq_event(struct mlx4_dev *dev, u32 cqn, int event_type)
+void mlx4_cq_event(struct mlx4_dev *dev, uint32_t cqn, int event_type)
 {
        struct mlx4_cq_table *cq_table = &mlx4_priv(dev)->cq_table;
        struct mlx4_cq *cq;
@@ -133,7 +133,7 @@ void mlx4_cq_event(struct mlx4_dev *dev, u32 cqn, int event_type)
 
        cq->event(cq, event_type);
 
-       if (atomic_dec_and_test(&cq->refcount))
+       if (atomic_sub_and_test(&cq->refcount, 1))
                complete(&cq->free);
 }
 
@@ -146,7 +146,7 @@ static int mlx4_SW2HW_CQ(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox,
 }
 
 static int mlx4_MODIFY_CQ(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox,
-                        int cq_num, u32 opmod)
+                        int cq_num, uint32_t opmod)
 {
        return mlx4_cmd(dev, mailbox->dma, cq_num, opmod, MLX4_CMD_MODIFY_CQ,
                        MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
@@ -161,7 +161,7 @@ static int mlx4_HW2SW_CQ(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox,
 }
 
 int mlx4_cq_modify(struct mlx4_dev *dev, struct mlx4_cq *cq,
-                  u16 count, u16 period)
+                  uint16_t count, uint16_t period)
 {
        struct mlx4_cmd_mailbox *mailbox;
        struct mlx4_cq_context *cq_context;
@@ -187,7 +187,7 @@ int mlx4_cq_resize(struct mlx4_dev *dev, struct mlx4_cq *cq,
 {
        struct mlx4_cmd_mailbox *mailbox;
        struct mlx4_cq_context *cq_context;
-       u64 mtt_addr;
+       uint64_t mtt_addr;
        int err;
 
        mailbox = mlx4_alloc_cmd_mailbox(dev);
@@ -195,7 +195,7 @@ int mlx4_cq_resize(struct mlx4_dev *dev, struct mlx4_cq *cq,
                return PTR_ERR(mailbox);
 
        cq_context = mailbox->buf;
-       cq_context->logsize_usrpage = cpu_to_be32(ilog2(entries) << 24);
+       cq_context->logsize_usrpage = cpu_to_be32(LOG2_UP(entries) << 24);
        cq_context->log_page_size   = mtt->page_shift - 12;
        mtt_addr = mlx4_mtt_addr(dev, mtt);
        cq_context->mtt_base_addr_h = mtt_addr >> 32;
@@ -218,11 +218,11 @@ int __mlx4_cq_alloc_icm(struct mlx4_dev *dev, int *cqn)
        if (*cqn == -1)
                return -ENOMEM;
 
-       err = mlx4_table_get(dev, &cq_table->table, *cqn, GFP_KERNEL);
+       err = mlx4_table_get(dev, &cq_table->table, *cqn, KMALLOC_WAIT);
        if (err)
                goto err_out;
 
-       err = mlx4_table_get(dev, &cq_table->cmpt_table, *cqn, GFP_KERNEL);
+       err = mlx4_table_get(dev, &cq_table->cmpt_table, *cqn, KMALLOC_WAIT);
        if (err)
                goto err_put;
        return 0;
@@ -237,7 +237,7 @@ err_out:
 
 static int mlx4_cq_alloc_icm(struct mlx4_dev *dev, int *cqn)
 {
-       u64 out_param;
+       uint64_t out_param;
        int err;
 
        if (mlx4_is_mfunc(dev)) {
@@ -266,7 +266,7 @@ void __mlx4_cq_free_icm(struct mlx4_dev *dev, int cqn)
 
 static void mlx4_cq_free_icm(struct mlx4_dev *dev, int cqn)
 {
-       u64 in_param = 0;
+       uint64_t in_param = 0;
        int err;
 
        if (mlx4_is_mfunc(dev)) {
@@ -281,7 +281,7 @@ static void mlx4_cq_free_icm(struct mlx4_dev *dev, int cqn)
 }
 
 int mlx4_cq_alloc(struct mlx4_dev *dev, int nent,
-                 struct mlx4_mtt *mtt, struct mlx4_uar *uar, u64 db_rec,
+                 struct mlx4_mtt *mtt, struct mlx4_uar *uar, uint64_t db_rec,
                  struct mlx4_cq *cq, unsigned vector, int collapsed,
                  int timestamp_en)
 {
@@ -289,7 +289,7 @@ int mlx4_cq_alloc(struct mlx4_dev *dev, int nent,
        struct mlx4_cq_table *cq_table = &priv->cq_table;
        struct mlx4_cmd_mailbox *mailbox;
        struct mlx4_cq_context *cq_context;
-       u64 mtt_addr;
+       uint64_t mtt_addr;
        int err;
 
        if (vector > dev->caps.num_comp_vectors + dev->caps.comp_pool)
@@ -301,9 +301,9 @@ int mlx4_cq_alloc(struct mlx4_dev *dev, int nent,
        if (err)
                return err;
 
-       spin_lock_irq(&cq_table->lock);
+       spin_lock_irqsave(&cq_table->lock);
        err = radix_tree_insert(&cq_table->tree, cq->cqn, cq);
-       spin_unlock_irq(&cq_table->lock);
+       spin_unlock_irqsave(&cq_table->lock);
        if (err)
                goto err_icm;
 
@@ -318,7 +318,7 @@ int mlx4_cq_alloc(struct mlx4_dev *dev, int nent,
        if (timestamp_en)
                cq_context->flags  |= cpu_to_be32(1 << 19);
 
-       cq_context->logsize_usrpage = cpu_to_be32((ilog2(nent) << 24) | uar->index);
+       cq_context->logsize_usrpage = cpu_to_be32((LOG2_UP(nent) << 24) | uar->index);
        cq_context->comp_eqn        = priv->eq_table.eq[vector].eqn;
        cq_context->log_page_size   = mtt->page_shift - MLX4_ICM_PAGE_SHIFT;
 
@@ -347,9 +347,9 @@ int mlx4_cq_alloc(struct mlx4_dev *dev, int nent,
        return 0;
 
 err_radix:
-       spin_lock_irq(&cq_table->lock);
+       spin_lock_irqsave(&cq_table->lock);
        radix_tree_delete(&cq_table->tree, cq->cqn);
-       spin_unlock_irq(&cq_table->lock);
+       spin_unlock_irqsave(&cq_table->lock);
 
 err_icm:
        mlx4_cq_free_icm(dev, cq->cqn);
@@ -370,11 +370,11 @@ void mlx4_cq_free(struct mlx4_dev *dev, struct mlx4_cq *cq)
 
        synchronize_irq(priv->eq_table.eq[cq->vector].irq);
 
-       spin_lock_irq(&cq_table->lock);
+       spin_lock_irqsave(&cq_table->lock);
        radix_tree_delete(&cq_table->tree, cq->cqn);
-       spin_unlock_irq(&cq_table->lock);
+       spin_unlock_irqsave(&cq_table->lock);
 
-       if (atomic_dec_and_test(&cq->refcount))
+       if (atomic_sub_and_test(&cq->refcount, 1))
                complete(&cq->free);
        wait_for_completion(&cq->free);
 
@@ -387,8 +387,8 @@ int mlx4_init_cq_table(struct mlx4_dev *dev)
        struct mlx4_cq_table *cq_table = &mlx4_priv(dev)->cq_table;
        int err;
 
-       spin_lock_init(&cq_table->lock);
-       INIT_RADIX_TREE(&cq_table->tree, GFP_ATOMIC);
+       spinlock_init_irqsave(&cq_table->lock);
+       INIT_RADIX_TREE(&cq_table->tree, 0);
        if (mlx4_is_slave(dev))
                return 0;
 
index 8a083d7..97d3e85 100644 (file)
@@ -38,7 +38,7 @@
 
 /* mlx4_en_read_clock - read raw cycle counter (to be used by time counter)
  */
-static cycle_t mlx4_en_read_clock(const struct cyclecounter *tc)
+static uint64_t mlx4_en_read_clock(const struct cyclecounter *tc)
 {
        struct mlx4_en_dev *mdev =
                container_of(tc, struct mlx4_en_dev, cycles);
@@ -47,23 +47,23 @@ static cycle_t mlx4_en_read_clock(const struct cyclecounter *tc)
        return mlx4_read_clock(dev) & tc->mask;
 }
 
-u64 mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe)
+uint64_t mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe)
 {
-       u64 hi, lo;
+       uint64_t hi, lo;
        struct mlx4_ts_cqe *ts_cqe = (struct mlx4_ts_cqe *)cqe;
 
-       lo = (u64)be16_to_cpu(ts_cqe->timestamp_lo);
-       hi = ((u64)be32_to_cpu(ts_cqe->timestamp_hi) + !lo) << 16;
+       lo = (uint64_t)be16_to_cpu(ts_cqe->timestamp_lo);
+       hi = ((uint64_t)be32_to_cpu(ts_cqe->timestamp_hi) + !lo) << 16;
 
        return hi | lo;
 }
 
 void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
                            struct skb_shared_hwtstamps *hwts,
-                           u64 timestamp)
+                           uint64_t timestamp)
 {
        unsigned long flags;
-       u64 nsec;
+       uint64_t nsec;
 
        read_lock_irqsave(&mdev->clock_lock, flags);
        nsec = timecounter_cyc2time(&mdev->clock, timestamp);
@@ -110,10 +110,10 @@ void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev)
  * Adjust the frequency of the PHC cycle counter by the indicated delta from
  * the base frequency.
  **/
-static int mlx4_en_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta)
+static int mlx4_en_phc_adjfreq(struct ptp_clock_info *ptp, int32_t delta)
 {
-       u64 adj;
-       u32 diff, mult;
+       uint64_t adj;
+       uint32_t diff, mult;
        int neg_adj = 0;
        unsigned long flags;
        struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
@@ -143,7 +143,7 @@ static int mlx4_en_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta)
  *
  * Adjust the timer by resetting the timecounter structure.
  **/
-static int mlx4_en_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)
+static int mlx4_en_phc_adjtime(struct ptp_clock_info *ptp, int64_t delta)
 {
        struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
                                                ptp_clock_info);
@@ -170,7 +170,7 @@ static int mlx4_en_phc_gettime(struct ptp_clock_info *ptp,
        struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
                                                ptp_clock_info);
        unsigned long flags;
-       u64 ns;
+       uint64_t ns;
 
        write_lock_irqsave(&mdev->clock_lock, flags);
        ns = timecounter_read(&mdev->clock);
@@ -194,7 +194,7 @@ static int mlx4_en_phc_settime(struct ptp_clock_info *ptp,
 {
        struct mlx4_en_dev *mdev = container_of(ptp, struct mlx4_en_dev,
                                                ptp_clock_info);
-       u64 ns = timespec64_to_ns(ts);
+       uint64_t ns = timespec64_to_ns(ts);
        unsigned long flags;
 
        /* reset the timecounter */
@@ -240,7 +240,7 @@ void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
 {
        struct mlx4_dev *dev = mdev->dev;
        unsigned long flags;
-       u64 ns, zero = 0;
+       uint64_t ns, zero = 0;
 
        rwlock_init(&mdev->clock_lock);
 
@@ -259,7 +259,7 @@ void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
 
        write_lock_irqsave(&mdev->clock_lock, flags);
        timecounter_init(&mdev->clock, &mdev->cycles,
-                        ktime_to_ns(ktime_get_real()));
+                        epoch_nsec());
        write_unlock_irqrestore(&mdev->clock_lock, flags);
 
        /* Calculate period in seconds to call the overflow watchdog - to make
index 22da4d0..a9cb808 100644 (file)
@@ -52,9 +52,9 @@ int mlx4_en_create_cq(struct mlx4_en_priv *priv,
        struct mlx4_en_cq *cq;
        int err;
 
-       cq = kzalloc_node(sizeof(*cq), GFP_KERNEL, node);
+       cq = kzalloc_node(sizeof(*cq), KMALLOC_WAIT, node);
        if (!cq) {
-               cq = kzalloc(sizeof(*cq), GFP_KERNEL);
+               cq = kzmalloc(sizeof(*cq), KMALLOC_WAIT);
                if (!cq) {
                        en_err(priv, "Failed to allocate CQ structure\n");
                        return -ENOMEM;
index f01918c..596a0af 100644 (file)
@@ -80,8 +80,8 @@ struct mlx4_congestion_control_mb_prio_802_1_qau_statistics {
        __be32 reserved3[4];
 };
 
-static int mlx4_en_dcbnl_ieee_getets(struct net_device *dev,
-                                  struct ieee_ets *ets)
+static int mlx4_en_dcbnl_ieee_getets(struct ether *dev,
+                                    struct ieee_ets *ets)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct ieee_ets *my_ets = &priv->ets;
@@ -136,7 +136,7 @@ static int mlx4_en_ets_validate(struct mlx4_en_priv *priv, struct ieee_ets *ets)
 }
 
 static int mlx4_en_config_port_scheduler(struct mlx4_en_priv *priv,
-               struct ieee_ets *ets, u16 *ratelimit)
+               struct ieee_ets *ets, uint16_t *ratelimit)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
        int num_strict = 0;
@@ -166,7 +166,7 @@ static int mlx4_en_config_port_scheduler(struct mlx4_en_priv *priv,
 }
 
 static int
-mlx4_en_dcbnl_ieee_setets(struct net_device *dev, struct ieee_ets *ets)
+mlx4_en_dcbnl_ieee_setets(struct ether *dev, struct ieee_ets *ets)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -189,8 +189,8 @@ mlx4_en_dcbnl_ieee_setets(struct net_device *dev, struct ieee_ets *ets)
        return 0;
 }
 
-static int mlx4_en_dcbnl_ieee_getpfc(struct net_device *dev,
-               struct ieee_pfc *pfc)
+static int mlx4_en_dcbnl_ieee_getpfc(struct ether *dev,
+                                    struct ieee_pfc *pfc)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
@@ -200,8 +200,8 @@ static int mlx4_en_dcbnl_ieee_getpfc(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev,
-               struct ieee_pfc *pfc)
+static int mlx4_en_dcbnl_ieee_setpfc(struct ether *dev,
+                                    struct ieee_pfc *pfc)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_port_profile *prof = priv->prof;
@@ -235,12 +235,12 @@ static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev,
        return err;
 }
 
-static u8 mlx4_en_dcbnl_getdcbx(struct net_device *dev)
+static uint8_t mlx4_en_dcbnl_getdcbx(struct ether *dev)
 {
        return DCB_CAP_DCBX_HOST | DCB_CAP_DCBX_VER_IEEE;
 }
 
-static u8 mlx4_en_dcbnl_setdcbx(struct net_device *dev, u8 mode)
+static uint8_t mlx4_en_dcbnl_setdcbx(struct ether *dev, uint8_t mode)
 {
        if ((mode & DCB_CAP_DCBX_LLD_MANAGED) ||
            (mode & DCB_CAP_DCBX_VER_CEE) ||
@@ -252,8 +252,8 @@ static u8 mlx4_en_dcbnl_setdcbx(struct net_device *dev, u8 mode)
 }
 
 #define MLX4_RATELIMIT_UNITS_IN_KB 100000 /* rate-limit HW unit in Kbps */
-static int mlx4_en_dcbnl_ieee_getmaxrate(struct net_device *dev,
-                                  struct ieee_maxrate *maxrate)
+static int mlx4_en_dcbnl_ieee_getmaxrate(struct ether *dev,
+                                        struct ieee_maxrate *maxrate)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int i;
@@ -265,11 +265,11 @@ static int mlx4_en_dcbnl_ieee_getmaxrate(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_dcbnl_ieee_setmaxrate(struct net_device *dev,
-               struct ieee_maxrate *maxrate)
+static int mlx4_en_dcbnl_ieee_setmaxrate(struct ether *dev,
+                                        struct ieee_maxrate *maxrate)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
-       u16 tmp[IEEE_8021QAZ_MAX_TCS];
+       uint16_t tmp[IEEE_8021QAZ_MAX_TCS];
        int i, err;
 
        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
@@ -293,14 +293,14 @@ static int mlx4_en_dcbnl_ieee_setmaxrate(struct net_device *dev,
 #define RPG_ENABLE_BIT 31
 #define CN_TAG_BIT     30
 
-static int mlx4_en_dcbnl_ieee_getqcn(struct net_device *dev,
+static int mlx4_en_dcbnl_ieee_getqcn(struct ether *dev,
                                     struct ieee_qcn *qcn)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_congestion_control_mb_prio_802_1_qau_params *hw_qcn;
        struct mlx4_cmd_mailbox *mailbox_out = NULL;
-       u64 mailbox_in_dma = 0;
-       u32 inmod = 0;
+       uint64_t mailbox_in_dma = 0;
+       uint32_t inmod = 0;
        int i, err;
 
        if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_QCN))
@@ -356,14 +356,14 @@ static int mlx4_en_dcbnl_ieee_getqcn(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_dcbnl_ieee_setqcn(struct net_device *dev,
+static int mlx4_en_dcbnl_ieee_setqcn(struct ether *dev,
                                     struct ieee_qcn *qcn)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_congestion_control_mb_prio_802_1_qau_params *hw_qcn;
        struct mlx4_cmd_mailbox *mailbox_in = NULL;
-       u64 mailbox_in_dma = 0;
-       u32 inmod = 0;
+       uint64_t mailbox_in_dma = 0;
+       uint32_t inmod = 0;
        int i, err;
 #define MODIFY_ENABLE_HIGH_MASK 0xc0000000
 #define MODIFY_ENABLE_LOW_MASK 0xffc00000
@@ -419,14 +419,14 @@ static int mlx4_en_dcbnl_ieee_setqcn(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_dcbnl_ieee_getqcnstats(struct net_device *dev,
+static int mlx4_en_dcbnl_ieee_getqcnstats(struct ether *dev,
                                          struct ieee_qcn_stats *qcn_stats)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_congestion_control_mb_prio_802_1_qau_statistics *hw_qcn_stats;
        struct mlx4_cmd_mailbox *mailbox_out = NULL;
-       u64 mailbox_in_dma = 0;
-       u32 inmod = 0;
+       uint64_t mailbox_in_dma = 0;
+       uint32_t inmod = 0;
        int i, err;
 
        if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_QCN))
index a2ddf3d..b07f7fd 100644 (file)
@@ -80,7 +80,7 @@ static int mlx4_en_moderation_update(struct mlx4_en_priv *priv)
 }
 
 static void
-mlx4_en_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
+mlx4_en_get_drvinfo(struct ether *dev, struct ethtool_drvinfo *drvinfo)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -198,23 +198,23 @@ static const char mlx4_en_test_names[][ETH_GSTRING_LEN]= {
        "Loopback Test",
 };
 
-static u32 mlx4_en_get_msglevel(struct net_device *dev)
+static uint32_t mlx4_en_get_msglevel(struct ether *dev)
 {
        return ((struct mlx4_en_priv *) netdev_priv(dev))->msg_enable;
 }
 
-static void mlx4_en_set_msglevel(struct net_device *dev, u32 val)
+static void mlx4_en_set_msglevel(struct ether *dev, uint32_t val)
 {
        ((struct mlx4_en_priv *) netdev_priv(dev))->msg_enable = val;
 }
 
-static void mlx4_en_get_wol(struct net_device *netdev,
+static void mlx4_en_get_wol(struct ether *netdev,
                            struct ethtool_wolinfo *wol)
 {
        struct mlx4_en_priv *priv = netdev_priv(netdev);
        int err = 0;
-       u64 config = 0;
-       u64 mask;
+       uint64_t config = 0;
+       uint64_t mask;
 
        if ((priv->port < 1) || (priv->port > 2)) {
                en_err(priv, "Failed to get WoL information\n");
@@ -247,13 +247,13 @@ static void mlx4_en_get_wol(struct net_device *netdev,
                wol->wolopts = 0;
 }
 
-static int mlx4_en_set_wol(struct net_device *netdev,
+static int mlx4_en_set_wol(struct ether *netdev,
                            struct ethtool_wolinfo *wol)
 {
        struct mlx4_en_priv *priv = netdev_priv(netdev);
-       u64 config = 0;
+       uint64_t config = 0;
        int err = 0;
-       u64 mask;
+       uint64_t mask;
 
        if ((priv->port < 1) || (priv->port > 2))
                return -EOPNOTSUPP;
@@ -322,7 +322,7 @@ bitmap_iterator_count(struct bitmap_iterator *h)
        return h->count;
 }
 
-static int mlx4_en_get_sset_count(struct net_device *dev, int sset)
+static int mlx4_en_get_sset_count(struct ether *dev, int sset)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct bitmap_iterator it;
@@ -348,8 +348,9 @@ static int mlx4_en_get_sset_count(struct net_device *dev, int sset)
        }
 }
 
-static void mlx4_en_get_ethtool_stats(struct net_device *dev,
-               struct ethtool_stats *stats, uint64_t *data)
+static void mlx4_en_get_ethtool_stats(struct ether *dev,
+                                     struct ethtool_stats *stats,
+                                     uint64_t *data)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int index = 0;
@@ -358,7 +359,7 @@ static void mlx4_en_get_ethtool_stats(struct net_device *dev,
 
        bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);
 
-       spin_lock_bh(&priv->stats_lock);
+       spin_lock(&priv->stats_lock);
 
        for (i = 0; i < NUM_MAIN_STATS; i++, bitmap_iterator_inc(&it))
                if (bitmap_iterator_test(&it))
@@ -372,21 +373,21 @@ static void mlx4_en_get_ethtool_stats(struct net_device *dev,
             i++, bitmap_iterator_inc(&it))
                if (bitmap_iterator_test(&it))
                        data[index++] =
-                               ((u64 *)&priv->rx_priority_flowstats)[i];
+                               ((uint64_t *)&priv->rx_priority_flowstats)[i];
 
        for (i = 0; i < NUM_FLOW_STATS_RX; i++, bitmap_iterator_inc(&it))
                if (bitmap_iterator_test(&it))
-                       data[index++] = ((u64 *)&priv->rx_flowstats)[i];
+                       data[index++] = ((uint64_t *)&priv->rx_flowstats)[i];
 
        for (i = 0; i < NUM_FLOW_PRIORITY_STATS_TX;
             i++, bitmap_iterator_inc(&it))
                if (bitmap_iterator_test(&it))
                        data[index++] =
-                               ((u64 *)&priv->tx_priority_flowstats)[i];
+                               ((uint64_t *)&priv->tx_priority_flowstats)[i];
 
        for (i = 0; i < NUM_FLOW_STATS_TX; i++, bitmap_iterator_inc(&it))
                if (bitmap_iterator_test(&it))
-                       data[index++] = ((u64 *)&priv->tx_flowstats)[i];
+                       data[index++] = ((uint64_t *)&priv->tx_flowstats)[i];
 
        for (i = 0; i < NUM_PKT_STATS; i++, bitmap_iterator_inc(&it))
                if (bitmap_iterator_test(&it))
@@ -405,17 +406,17 @@ static void mlx4_en_get_ethtool_stats(struct net_device *dev,
                data[index++] = priv->rx_ring[i]->cleaned;
 #endif
        }
-       spin_unlock_bh(&priv->stats_lock);
+       spin_unlock(&priv->stats_lock);
 
 }
 
-static void mlx4_en_self_test(struct net_device *dev,
-                             struct ethtool_test *etest, u64 *buf)
+static void mlx4_en_self_test(struct ether *dev,
+                             struct ethtool_test *etest, uint64_t *buf)
 {
        mlx4_en_ex_selftest(dev, &etest->flags, buf);
 }
 
-static void mlx4_en_get_strings(struct net_device *dev,
+static void mlx4_en_get_strings(struct ether *dev,
                                uint32_t stringset, uint8_t *data)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -490,11 +491,11 @@ static void mlx4_en_get_strings(struct net_device *dev,
        }
 }
 
-static u32 mlx4_en_autoneg_get(struct net_device *dev)
+static uint32_t mlx4_en_autoneg_get(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
-       u32 autoneg = AUTONEG_DISABLE;
+       uint32_t autoneg = AUTONEG_DISABLE;
 
        if ((mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP) &&
            (priv->port_state.flags & MLX4_EN_PORT_ANE))
@@ -503,9 +504,9 @@ static u32 mlx4_en_autoneg_get(struct net_device *dev)
        return autoneg;
 }
 
-static u32 ptys_get_supported_port(struct mlx4_ptys_reg *ptys_reg)
+static uint32_t ptys_get_supported_port(struct mlx4_ptys_reg *ptys_reg)
 {
-       u32 eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);
+       uint32_t eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);
 
        if (eth_proto & (MLX4_PROT_MASK(MLX4_10GBASE_T)
                         | MLX4_PROT_MASK(MLX4_1000BASE_T)
@@ -533,9 +534,9 @@ static u32 ptys_get_supported_port(struct mlx4_ptys_reg *ptys_reg)
        return 0;
 }
 
-static u32 ptys_get_active_port(struct mlx4_ptys_reg *ptys_reg)
+static uint32_t ptys_get_active_port(struct mlx4_ptys_reg *ptys_reg)
 {
-       u32 eth_proto = be32_to_cpu(ptys_reg->eth_proto_oper);
+       uint32_t eth_proto = be32_to_cpu(ptys_reg->eth_proto_oper);
 
        if (!eth_proto) /* link down */
                eth_proto = be32_to_cpu(ptys_reg->eth_proto_cap);
@@ -580,7 +581,7 @@ enum ethtool_report {
 };
 
 /* Translates mlx4 link mode to equivalent ethtool Link modes/speed */
-static u32 ptys2ethtool_map[MLX4_LINK_MODES_SZ][3] = {
+static uint32_t ptys2ethtool_map[MLX4_LINK_MODES_SZ][3] = {
        [MLX4_100BASE_TX] = {
                SUPPORTED_100baseT_Full,
                ADVERTISED_100baseT_Full,
@@ -673,10 +674,11 @@ static u32 ptys2ethtool_map[MLX4_LINK_MODES_SZ][3] = {
                },
 };
 
-static u32 ptys2ethtool_link_modes(u32 eth_proto, enum ethtool_report report)
+static uint32_t ptys2ethtool_link_modes(uint32_t eth_proto,
+                                       enum ethtool_report report)
 {
        int i;
-       u32 link_modes = 0;
+       uint32_t link_modes = 0;
 
        for (i = 0; i < MLX4_LINK_MODES_SZ; i++) {
                if (eth_proto & MLX4_PROT_MASK(i))
@@ -685,10 +687,11 @@ static u32 ptys2ethtool_link_modes(u32 eth_proto, enum ethtool_report report)
        return link_modes;
 }
 
-static u32 ethtool2ptys_link_modes(u32 link_modes, enum ethtool_report report)
+static uint32_t ethtool2ptys_link_modes(uint32_t link_modes,
+                                       enum ethtool_report report)
 {
        int i;
-       u32 ptys_modes = 0;
+       uint32_t ptys_modes = 0;
 
        for (i = 0; i < MLX4_LINK_MODES_SZ; i++) {
                if (ptys2ethtool_map[i][report] & link_modes)
@@ -698,10 +701,10 @@ static u32 ethtool2ptys_link_modes(u32 link_modes, enum ethtool_report report)
 }
 
 /* Convert actual speed (SPEED_XXX) to ptys link modes */
-static u32 speed2ptys_link_modes(u32 speed)
+static uint32_t speed2ptys_link_modes(uint32_t speed)
 {
        int i;
-       u32 ptys_modes = 0;
+       uint32_t ptys_modes = 0;
 
        for (i = 0; i < MLX4_LINK_MODES_SZ; i++) {
                if (ptys2ethtool_map[i][SPEED] == speed)
@@ -710,12 +713,12 @@ static u32 speed2ptys_link_modes(u32 speed)
        return ptys_modes;
 }
 
-static int ethtool_get_ptys_settings(struct net_device *dev,
+static int ethtool_get_ptys_settings(struct ether *dev,
                                     struct ethtool_cmd *cmd)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_ptys_reg ptys_reg;
-       u32 eth_proto;
+       uint32_t eth_proto;
        int ret;
 
        memset(&ptys_reg, 0, sizeof(ptys_reg));
@@ -784,7 +787,7 @@ static int ethtool_get_ptys_settings(struct net_device *dev,
        return ret;
 }
 
-static void ethtool_get_default_settings(struct net_device *dev,
+static void ethtool_get_default_settings(struct ether *dev,
                                         struct ethtool_cmd *cmd)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -811,7 +814,7 @@ static void ethtool_get_default_settings(struct net_device *dev,
        }
 }
 
-static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int mlx4_en_get_settings(struct ether *dev, struct ethtool_cmd *cmd)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int ret = -EINVAL;
@@ -839,7 +842,7 @@ static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 }
 
 /* Calculate PTYS admin according ethtool speed (SPEED_XXX) */
-static __be32 speed_set_ptys_admin(struct mlx4_en_priv *priv, u32 speed,
+static __be32 speed_set_ptys_admin(struct mlx4_en_priv *priv, uint32_t speed,
                                   __be32 proto_cap)
 {
        __be32 proto_admin = 0;
@@ -849,7 +852,7 @@ static __be32 speed_set_ptys_admin(struct mlx4_en_priv *priv, u32 speed,
                en_info(priv, "Speed was set to 0, Reset advertised Link Modes to default (%x)\n",
                        be32_to_cpu(proto_cap));
        } else {
-               u32 ptys_link_modes = speed2ptys_link_modes(speed);
+               uint32_t ptys_link_modes = speed2ptys_link_modes(speed);
 
                proto_admin = cpu_to_be32(ptys_link_modes) & proto_cap;
                en_info(priv, "Setting Speed to %d\n", speed);
@@ -857,14 +860,14 @@ static __be32 speed_set_ptys_admin(struct mlx4_en_priv *priv, u32 speed,
        return proto_admin;
 }
 
-static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static int mlx4_en_set_settings(struct ether *dev, struct ethtool_cmd *cmd)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_ptys_reg ptys_reg;
        __be32 proto_admin;
        int ret;
 
-       u32 ptys_adv = ethtool2ptys_link_modes(cmd->advertising, ADVERTISED);
+       uint32_t ptys_adv = ethtool2ptys_link_modes(cmd->advertising, ADVERTISED);
        int speed = ethtool_cmd_speed(cmd);
 
        en_dbg(DRV, priv, "Set Speed=%d adv=0x%x autoneg=%d duplex=%d\n",
@@ -911,19 +914,19 @@ static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
                return ret;
        }
 
-       mutex_lock(&priv->mdev->state_lock);
+       qlock(&priv->mdev->state_lock);
        if (priv->port_up) {
                en_warn(priv, "Port link mode changed, restarting port...\n");
                mlx4_en_stop_port(dev, 1);
                if (mlx4_en_start_port(dev))
                        en_err(priv, "Failed restarting port %d\n", priv->port);
        }
-       mutex_unlock(&priv->mdev->state_lock);
+       qunlock(&priv->mdev->state_lock);
        return 0;
 }
 
-static int mlx4_en_get_coalesce(struct net_device *dev,
-                             struct ethtool_coalesce *coal)
+static int mlx4_en_get_coalesce(struct ether *dev,
+                               struct ethtool_coalesce *coal)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
@@ -944,8 +947,8 @@ static int mlx4_en_get_coalesce(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_set_coalesce(struct net_device *dev,
-                             struct ethtool_coalesce *coal)
+static int mlx4_en_set_coalesce(struct ether *dev,
+                               struct ethtool_coalesce *coal)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
@@ -980,8 +983,8 @@ static int mlx4_en_set_coalesce(struct net_device *dev,
        return mlx4_en_moderation_update(priv);
 }
 
-static int mlx4_en_set_pauseparam(struct net_device *dev,
-                               struct ethtool_pauseparam *pause)
+static int mlx4_en_set_pauseparam(struct ether *dev,
+                                 struct ethtool_pauseparam *pause)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1010,8 +1013,8 @@ static int mlx4_en_set_pauseparam(struct net_device *dev,
        return err;
 }
 
-static void mlx4_en_get_pauseparam(struct net_device *dev,
-                                struct ethtool_pauseparam *pause)
+static void mlx4_en_get_pauseparam(struct ether *dev,
+                                  struct ethtool_pauseparam *pause)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
@@ -1019,31 +1022,31 @@ static void mlx4_en_get_pauseparam(struct net_device *dev,
        pause->rx_pause = priv->prof->rx_pause;
 }
 
-static int mlx4_en_set_ringparam(struct net_device *dev,
+static int mlx4_en_set_ringparam(struct ether *dev,
                                 struct ethtool_ringparam *param)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
-       u32 rx_size, tx_size;
+       uint32_t rx_size, tx_size;
        int port_up = 0;
        int err = 0;
 
        if (param->rx_jumbo_pending || param->rx_mini_pending)
                return -EINVAL;
 
-       rx_size = roundup_pow_of_two(param->rx_pending);
-       rx_size = max_t(u32, rx_size, MLX4_EN_MIN_RX_SIZE);
-       rx_size = min_t(u32, rx_size, MLX4_EN_MAX_RX_SIZE);
-       tx_size = roundup_pow_of_two(param->tx_pending);
-       tx_size = max_t(u32, tx_size, MLX4_EN_MIN_TX_SIZE);
-       tx_size = min_t(u32, tx_size, MLX4_EN_MAX_TX_SIZE);
+       rx_size = ROUNDUPPWR2(param->rx_pending);
+       rx_size = MAX_T(uint32_t, rx_size, MLX4_EN_MIN_RX_SIZE);
+       rx_size = MIN_T(uint32_t, rx_size, MLX4_EN_MAX_RX_SIZE);
+       tx_size = ROUNDUPPWR2(param->tx_pending);
+       tx_size = MAX_T(uint32_t, tx_size, MLX4_EN_MIN_TX_SIZE);
+       tx_size = MIN_T(uint32_t, tx_size, MLX4_EN_MAX_TX_SIZE);
 
        if (rx_size == (priv->port_up ? priv->rx_ring[0]->actual_size :
                                        priv->rx_ring[0]->size) &&
            tx_size == priv->tx_ring[0]->size)
                return 0;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (priv->port_up) {
                port_up = 1;
                mlx4_en_stop_port(dev, 1);
@@ -1068,11 +1071,11 @@ static int mlx4_en_set_ringparam(struct net_device *dev,
        err = mlx4_en_moderation_update(priv);
 
 out:
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
        return err;
 }
 
-static void mlx4_en_get_ringparam(struct net_device *dev,
+static void mlx4_en_get_ringparam(struct ether *dev,
                                  struct ethtool_ringparam *param)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -1085,19 +1088,19 @@ static void mlx4_en_get_ringparam(struct net_device *dev,
        param->tx_pending = priv->tx_ring[0]->size;
 }
 
-static u32 mlx4_en_get_rxfh_indir_size(struct net_device *dev)
+static uint32_t mlx4_en_get_rxfh_indir_size(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
        return priv->rx_ring_num;
 }
 
-static u32 mlx4_en_get_rxfh_key_size(struct net_device *netdev)
+static uint32_t mlx4_en_get_rxfh_key_size(struct ether *netdev)
 {
        return MLX4_EN_RSS_KEY_SIZE;
 }
 
-static int mlx4_en_check_rxfh_func(struct net_device *dev, u8 hfunc)
+static int mlx4_en_check_rxfh_func(struct ether *dev, uint8_t hfunc)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
@@ -1105,13 +1108,13 @@ static int mlx4_en_check_rxfh_func(struct net_device *dev, u8 hfunc)
        if (hfunc == ETH_RSS_HASH_TOP) {
                if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RSS_TOP))
                        return -EINVAL;
-               if (!(dev->features & NETIF_F_RXHASH))
+               if (!(dev->feat & NETIF_F_RXHASH))
                        en_warn(priv, "Toeplitz hash function should be used in conjunction with RX hashing for optimal performance\n");
                return 0;
        } else if (hfunc == ETH_RSS_HASH_XOR) {
                if (!(priv->mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RSS_XOR))
                        return -EINVAL;
-               if (dev->features & NETIF_F_RXHASH)
+               if (dev->feat & NETIF_F_RXHASH)
                        en_warn(priv, "Enabling both XOR Hash function and RX Hashing can limit RPS functionality\n");
                return 0;
        }
@@ -1119,8 +1122,9 @@ static int mlx4_en_check_rxfh_func(struct net_device *dev, u8 hfunc)
        return -EINVAL;
 }
 
-static int mlx4_en_get_rxfh(struct net_device *dev, u32 *ring_index, u8 *key,
-                           u8 *hfunc)
+static int mlx4_en_get_rxfh(struct ether *dev, uint32_t *ring_index,
+                           uint8_t *key,
+                           uint8_t *hfunc)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_rss_map *rss_map = &priv->rss_map;
@@ -1129,7 +1133,7 @@ static int mlx4_en_get_rxfh(struct net_device *dev, u32 *ring_index, u8 *key,
        int err = 0;
 
        rss_rings = priv->prof->rss_rings ?: priv->rx_ring_num;
-       rss_rings = 1 << ilog2(rss_rings);
+       rss_rings = 1 << LOG2_UP(rss_rings);
 
        while (n--) {
                if (!ring_index)
@@ -1144,8 +1148,9 @@ static int mlx4_en_get_rxfh(struct net_device *dev, u32 *ring_index, u8 *key,
        return err;
 }
 
-static int mlx4_en_set_rxfh(struct net_device *dev, const u32 *ring_index,
-                           const u8 *key, const u8 hfunc)
+static int mlx4_en_set_rxfh(struct ether *dev,
+                           const uint32_t *ring_index,
+                           const uint8_t *key, const uint8_t hfunc)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1171,7 +1176,7 @@ static int mlx4_en_set_rxfh(struct net_device *dev, const u32 *ring_index,
                rss_rings = priv->rx_ring_num;
 
        /* RSS table size must be an order of 2 */
-       if (!is_power_of_2(rss_rings))
+       if (!IS_PWR2(rss_rings))
                return -EINVAL;
 
        if (hfunc != ETH_RSS_HASH_NO_CHANGE) {
@@ -1180,7 +1185,7 @@ static int mlx4_en_set_rxfh(struct net_device *dev, const u32 *ring_index,
                        return err;
        }
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (priv->port_up) {
                port_up = 1;
                mlx4_en_stop_port(dev, 1);
@@ -1199,14 +1204,14 @@ static int mlx4_en_set_rxfh(struct net_device *dev, const u32 *ring_index,
                        en_err(priv, "Failed starting port\n");
        }
 
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
        return err;
 }
 
 #define all_zeros_or_all_ones(field)           \
        ((field) == 0 || (field) == (__force typeof(field))-1)
 
-static int mlx4_en_validate_flow(struct net_device *dev,
+static int mlx4_en_validate_flow(struct ether *dev,
                                 struct ethtool_rxnfc *cmd)
 {
        struct ethtool_usrip4_spec *l3_mask;
@@ -1288,8 +1293,8 @@ static int mlx4_en_ethtool_add_mac_rule(struct ethtool_rxnfc *cmd,
        __be64 mac_msk = cpu_to_be64(MLX4_MAC_MASK << 16);
 
        spec_l2->id = MLX4_NET_TRANS_RULE_ID_ETH;
-       memcpy(spec_l2->eth.dst_mac_msk, &mac_msk, ETH_ALEN);
-       memcpy(spec_l2->eth.dst_mac, mac, ETH_ALEN);
+       memcpy(spec_l2->eth.dst_mac_msk, &mac_msk, Eaddrlen);
+       memcpy(spec_l2->eth.dst_mac, mac, Eaddrlen);
 
        if ((cmd->fs.flow_type & FLOW_EXT) &&
            (cmd->fs.m_ext.vlan_tci & cpu_to_be16(VLAN_VID_MASK))) {
@@ -1309,13 +1314,13 @@ static int mlx4_en_ethtool_add_mac_rule_by_ipv4(struct mlx4_en_priv *priv,
                                                __be32 ipv4_dst)
 {
 #ifdef CONFIG_INET
-       unsigned char mac[ETH_ALEN];
+       unsigned char mac[Eaddrlen];
 
        if (!ipv4_is_multicast(ipv4_dst)) {
                if (cmd->fs.flow_type & FLOW_MAC_EXT)
-                       memcpy(&mac, cmd->fs.h_ext.h_dest, ETH_ALEN);
+                       memcpy(&mac, cmd->fs.h_ext.h_dest, Eaddrlen);
                else
-                       memcpy(&mac, priv->dev->dev_addr, ETH_ALEN);
+                       memcpy(&mac, priv->dev->ea, Eaddrlen);
        } else {
                ip_eth_mc_map(ipv4_dst, mac);
        }
@@ -1335,8 +1340,8 @@ static int add_ip_rule(struct mlx4_en_priv *priv,
        struct mlx4_spec_list *spec_l3 = NULL;
        struct ethtool_usrip4_spec *l3_mask = &cmd->fs.m_u.usr_ip4_spec;
 
-       spec_l3 = kzalloc(sizeof(*spec_l3), GFP_KERNEL);
-       spec_l2 = kzalloc(sizeof(*spec_l2), GFP_KERNEL);
+       spec_l3 = kzmalloc(sizeof(*spec_l3), KMALLOC_WAIT);
+       spec_l2 = kzmalloc(sizeof(*spec_l2), KMALLOC_WAIT);
        if (!spec_l2 || !spec_l3) {
                err = -ENOMEM;
                goto free_spec;
@@ -1374,9 +1379,9 @@ static int add_tcp_udp_rule(struct mlx4_en_priv *priv,
        struct mlx4_spec_list *spec_l4 = NULL;
        struct ethtool_tcpip4_spec *l4_mask = &cmd->fs.m_u.tcp_ip4_spec;
 
-       spec_l2 = kzalloc(sizeof(*spec_l2), GFP_KERNEL);
-       spec_l3 = kzalloc(sizeof(*spec_l3), GFP_KERNEL);
-       spec_l4 = kzalloc(sizeof(*spec_l4), GFP_KERNEL);
+       spec_l2 = kzmalloc(sizeof(*spec_l2), KMALLOC_WAIT);
+       spec_l3 = kzmalloc(sizeof(*spec_l3), KMALLOC_WAIT);
+       spec_l4 = kzmalloc(sizeof(*spec_l4), KMALLOC_WAIT);
        if (!spec_l2 || !spec_l3 || !spec_l4) {
                err = -ENOMEM;
                goto free_spec;
@@ -1432,7 +1437,7 @@ free_spec:
        return err;
 }
 
-static int mlx4_en_ethtool_to_net_trans_rule(struct net_device *dev,
+static int mlx4_en_ethtool_to_net_trans_rule(struct ether *dev,
                                             struct ethtool_rxnfc *cmd,
                                             struct list_head *rule_list_h)
 {
@@ -1447,7 +1452,7 @@ static int mlx4_en_ethtool_to_net_trans_rule(struct net_device *dev,
 
        switch (cmd->fs.flow_type & ~(FLOW_EXT | FLOW_MAC_EXT)) {
        case ETHER_FLOW:
-               spec_l2 = kzalloc(sizeof(*spec_l2), GFP_KERNEL);
+               spec_l2 = kzmalloc(sizeof(*spec_l2), KMALLOC_WAIT);
                if (!spec_l2)
                        return -ENOMEM;
 
@@ -1472,15 +1477,15 @@ static int mlx4_en_ethtool_to_net_trans_rule(struct net_device *dev,
        return err;
 }
 
-static int mlx4_en_flow_replace(struct net_device *dev,
+static int mlx4_en_flow_replace(struct ether *dev,
                                struct ethtool_rxnfc *cmd)
 {
        int err;
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct ethtool_flow_id *loc_rule;
        struct mlx4_spec_list *spec, *tmp_spec;
-       u32 qpn;
-       u64 reg_id;
+       uint32_t qpn;
+       uint64_t reg_id;
 
        struct mlx4_net_trans_rule rule = {
                .queue_mode = MLX4_NET_TRANS_Q_FIFO,
@@ -1548,7 +1553,7 @@ out_free_list:
        return err;
 }
 
-static int mlx4_en_flow_detach(struct net_device *dev,
+static int mlx4_en_flow_detach(struct ether *dev,
                               struct ethtool_rxnfc *cmd)
 {
        int err = 0;
@@ -1578,7 +1583,7 @@ out:
 
 }
 
-static int mlx4_en_get_flow(struct net_device *dev, struct ethtool_rxnfc *cmd,
+static int mlx4_en_get_flow(struct ether *dev, struct ethtool_rxnfc *cmd,
                            int loc)
 {
        int err = 0;
@@ -1610,8 +1615,8 @@ static int mlx4_en_get_num_flows(struct mlx4_en_priv *priv)
 
 }
 
-static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
-                            u32 *rule_locs)
+static int mlx4_en_get_rxnfc(struct ether *dev, struct ethtool_rxnfc *cmd,
+                            uint32_t *rule_locs)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1652,7 +1657,7 @@ static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
        return err;
 }
 
-static int mlx4_en_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
+static int mlx4_en_set_rxnfc(struct ether *dev, struct ethtool_rxnfc *cmd)
 {
        int err = 0;
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -1677,7 +1682,7 @@ static int mlx4_en_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
        return err;
 }
 
-static void mlx4_en_get_channels(struct net_device *dev,
+static void mlx4_en_get_channels(struct ether *dev,
                                 struct ethtool_channels *channel)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -1691,7 +1696,7 @@ static void mlx4_en_get_channels(struct net_device *dev,
        channel->tx_count = priv->tx_ring_num / MLX4_EN_NUM_UP;
 }
 
-static int mlx4_en_set_channels(struct net_device *dev,
+static int mlx4_en_set_channels(struct ether *dev,
                                struct ethtool_channels *channel)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -1705,7 +1710,7 @@ static int mlx4_en_set_channels(struct net_device *dev,
            !channel->tx_count || !channel->rx_count)
                return -EINVAL;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (priv->port_up) {
                port_up = 1;
                mlx4_en_stop_port(dev, 1);
@@ -1741,11 +1746,11 @@ static int mlx4_en_set_channels(struct net_device *dev,
        err = mlx4_en_moderation_update(priv);
 
 out:
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
        return err;
 }
 
-static int mlx4_en_get_ts_info(struct net_device *dev,
+static int mlx4_en_get_ts_info(struct ether *dev,
                               struct ethtool_ts_info *info)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -1777,7 +1782,7 @@ static int mlx4_en_get_ts_info(struct net_device *dev,
        return ret;
 }
 
-static int mlx4_en_set_priv_flags(struct net_device *dev, u32 flags)
+static int mlx4_en_set_priv_flags(struct ether *dev, uint32_t flags)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        bool bf_enabled_new = !!(flags & MLX4_EN_PRIV_FLAGS_BLUEFLAME);
@@ -1812,14 +1817,14 @@ static int mlx4_en_set_priv_flags(struct net_device *dev, u32 flags)
        return 0;
 }
 
-static u32 mlx4_en_get_priv_flags(struct net_device *dev)
+static uint32_t mlx4_en_get_priv_flags(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
        return priv->pflags;
 }
 
-static int mlx4_en_get_tunable(struct net_device *dev,
+static int mlx4_en_get_tunable(struct ether *dev,
                               const struct ethtool_tunable *tuna,
                               void *data)
 {
@@ -1828,7 +1833,7 @@ static int mlx4_en_get_tunable(struct net_device *dev,
 
        switch (tuna->id) {
        case ETHTOOL_TX_COPYBREAK:
-               *(u32 *)data = priv->prof->inline_thold;
+               *(uint32_t *)data = priv->prof->inline_thold;
                break;
        default:
                ret = -EINVAL;
@@ -1838,7 +1843,7 @@ static int mlx4_en_get_tunable(struct net_device *dev,
        return ret;
 }
 
-static int mlx4_en_set_tunable(struct net_device *dev,
+static int mlx4_en_set_tunable(struct ether *dev,
                               const struct ethtool_tunable *tuna,
                               const void *data)
 {
@@ -1847,7 +1852,7 @@ static int mlx4_en_set_tunable(struct net_device *dev,
 
        switch (tuna->id) {
        case ETHTOOL_TX_COPYBREAK:
-               val = *(u32 *)data;
+               val = *(uint32_t *)data;
                if (val < MIN_PKT_LEN || val > MAX_INLINE)
                        ret = -EINVAL;
                else
@@ -1861,13 +1866,13 @@ static int mlx4_en_set_tunable(struct net_device *dev,
        return ret;
 }
 
-static int mlx4_en_get_module_info(struct net_device *dev,
+static int mlx4_en_get_module_info(struct ether *dev,
                                   struct ethtool_modinfo *modinfo)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        int ret;
-       u8 data[4];
+       uint8_t data[4];
 
        /* Read first 2 bytes to get Module & REV ID */
        ret = mlx4_get_module_info(mdev->dev, priv->port,
@@ -1904,9 +1909,9 @@ static int mlx4_en_get_module_info(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_get_module_eeprom(struct net_device *dev,
+static int mlx4_en_get_module_eeprom(struct ether *dev,
                                     struct ethtool_eeprom *ee,
-                                    u8 *data)
+                                    uint8_t *data)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1942,11 +1947,11 @@ static int mlx4_en_get_module_eeprom(struct net_device *dev,
        return 0;
 }
 
-static int mlx4_en_set_phys_id(struct net_device *dev,
+static int mlx4_en_set_phys_id(struct ether *dev,
                               enum ethtool_phys_id_state state)
 {
        int err;
-       u16 beacon_duration;
+       uint16_t beacon_duration;
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
 
index 913b716..8c749ec 100644 (file)
@@ -98,7 +98,7 @@ void en_print(const char *level, const struct mlx4_en_priv *priv,
        va_end(args);
 }
 
-void mlx4_en_update_loopback_state(struct net_device *dev,
+void mlx4_en_update_loopback_state(struct ether *dev,
                                   netdev_features_t features)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -133,7 +133,7 @@ static int mlx4_en_get_profile(struct mlx4_en_dev *mdev)
        params->udp_rss = udp_rss;
        params->num_tx_rings_p_up = mlx4_low_memory_profile() ?
                MLX4_EN_MIN_TX_RING_P_UP :
-               min_t(int, num_online_cpus(), MLX4_EN_MAX_TX_RING_P_UP);
+               MIN_T(int, num_online_cpus(), MLX4_EN_MAX_TX_RING_P_UP);
 
        if (params->udp_rss && !(mdev->dev->caps.flags
                                        & MLX4_DEV_CAP_FLAG_UDP_RSS)) {
@@ -156,7 +156,7 @@ static int mlx4_en_get_profile(struct mlx4_en_dev *mdev)
        return 0;
 }
 
-static void *mlx4_en_get_netdev(struct mlx4_dev *dev, void *ctx, u8 port)
+static void *mlx4_en_get_netdev(struct mlx4_dev *dev, void *ctx, uint8_t port)
 {
        struct mlx4_en_dev *endev = ctx;
 
@@ -202,9 +202,9 @@ static void mlx4_en_remove(struct mlx4_dev *dev, void *endev_ptr)
        struct mlx4_en_dev *mdev = endev_ptr;
        int i;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        mdev->device_up = false;
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 
        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH)
                if (mdev->pndev[i])
@@ -231,7 +231,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
 
        printk_once(KERN_INFO "%s", mlx4_en_version);
 
-       mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
+       mdev = kzmalloc(sizeof(*mdev), KMALLOC_WAIT);
        if (!mdev)
                goto err_free_res;
 
@@ -245,7 +245,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
                                PAGE_SIZE);
        if (!mdev->uar_map)
                goto err_uar;
-       spin_lock_init(&mdev->uar_lock);
+       spinlock_init_irqsave(&mdev->uar_lock);
 
        mdev->dev = dev;
        mdev->dma_device = &dev->persist->pdev->dev;
@@ -294,7 +294,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
 
        /* At this stage all non-port specific tasks are complete:
         * mark the card state as up */
-       mutex_init(&mdev->state_lock);
+       qlock_init(&mdev->state_lock);
        mdev->device_up = true;
 
        /* Setup ports */
index cf467a9..1b2d304 100644 (file)
@@ -49,7 +49,7 @@
 #include "mlx4_en.h"
 #include "en_port.h"
 
-int mlx4_en_setup_tc(struct net_device *dev, u8 up)
+int mlx4_en_setup_tc(struct ether *dev, uint8_t up)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int i;
@@ -74,7 +74,7 @@ int mlx4_en_setup_tc(struct net_device *dev, u8 up)
 static int mlx4_en_low_latency_recv(struct napi_struct *napi)
 {
        struct mlx4_en_cq *cq = container_of(napi, struct mlx4_en_cq, napi);
-       struct net_device *dev = cq->dev;
+       struct ether *dev = cq->dev;
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_rx_ring *rx_ring = priv->rx_ring[cq->ring];
        int done;
@@ -103,7 +103,7 @@ struct mlx4_en_filter {
        struct list_head next;
        struct work_struct work;
 
-       u8     ip_proto;
+       uint8_t     ip_proto;
        __be32 src_ip;
        __be32 dst_ip;
        __be16 src_port;
@@ -111,10 +111,10 @@ struct mlx4_en_filter {
 
        int rxq_index;
        struct mlx4_en_priv *priv;
-       u32 flow_id;                    /* RFS infrastructure id */
+       uint32_t flow_id;                       /* RFS infrastructure id */
        int id;                         /* mlx4_en driver id */
-       u64 reg_id;                     /* Flow steering API id */
-       u8 activated;                   /* Used to prevent expiry before filter
+       uint64_t reg_id;                        /* Flow steering API id */
+       uint8_t activated;                      /* Used to prevent expiry before filter
                                         * is attached
                                         */
        struct hlist_node filter_chain;
@@ -122,7 +122,7 @@ struct mlx4_en_filter {
 
 static void mlx4_en_filter_rfs_expire(struct mlx4_en_priv *priv);
 
-static enum mlx4_net_trans_rule_id mlx4_ip_proto_to_trans_rule_id(u8 ip_proto)
+static enum mlx4_net_trans_rule_id mlx4_ip_proto_to_trans_rule_id(uint8_t ip_proto)
 {
        switch (ip_proto) {
        case IPPROTO_UDP:
@@ -187,8 +187,8 @@ static void mlx4_en_filter_work(struct work_struct *work)
        list_add_tail(&spec_tcp_udp.list, &rule.list);
 
        rule.qpn = priv->rss_map.qps[filter->rxq_index].qpn;
-       memcpy(spec_eth.eth.dst_mac, priv->dev->dev_addr, ETH_ALEN);
-       memcpy(spec_eth.eth.dst_mac_msk, &mac_mask, ETH_ALEN);
+       memcpy(spec_eth.eth.dst_mac, priv->dev->ea, Eaddrlen);
+       memcpy(spec_eth.eth.dst_mac_msk, &mac_mask, Eaddrlen);
 
        filter->activated = 0;
 
@@ -226,12 +226,12 @@ filter_hash_bucket(struct mlx4_en_priv *priv, __be32 src_ip, __be32 dst_ip,
 
 static struct mlx4_en_filter *
 mlx4_en_filter_alloc(struct mlx4_en_priv *priv, int rxq_index, __be32 src_ip,
-                    __be32 dst_ip, u8 ip_proto, __be16 src_port,
-                    __be16 dst_port, u32 flow_id)
+                    __be32 dst_ip, uint8_t ip_proto, __be16 src_port,
+                    __be16 dst_port, uint32_t flow_id)
 {
        struct mlx4_en_filter *filter = NULL;
 
-       filter = kzalloc(sizeof(struct mlx4_en_filter), GFP_ATOMIC);
+       filter = kzmalloc(sizeof(struct mlx4_en_filter), 0);
        if (!filter)
                return NULL;
 
@@ -273,7 +273,7 @@ static void mlx4_en_filter_free(struct mlx4_en_filter *filter)
 
 static inline struct mlx4_en_filter *
 mlx4_en_filter_find(struct mlx4_en_priv *priv, __be32 src_ip, __be32 dst_ip,
-                   u8 ip_proto, __be16 src_port, __be16 dst_port)
+                   uint8_t ip_proto, __be16 src_port, __be16 dst_port)
 {
        struct mlx4_en_filter *filter;
        struct mlx4_en_filter *ret = NULL;
@@ -296,14 +296,14 @@ mlx4_en_filter_find(struct mlx4_en_priv *priv, __be32 src_ip, __be32 dst_ip,
 }
 
 static int
-mlx4_en_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
-                  u16 rxq_index, u32 flow_id)
+mlx4_en_filter_rfs(struct ether *net_dev, const struct sk_buff *skb,
+                  uint16_t rxq_index, uint32_t flow_id)
 {
        struct mlx4_en_priv *priv = netdev_priv(net_dev);
        struct mlx4_en_filter *filter;
        const struct iphdr *ip;
        const __be16 *ports;
-       u8 ip_proto;
+       uint8_t ip_proto;
        __be32 src_ip;
        __be32 dst_ip;
        __be16 src_port;
@@ -311,7 +311,7 @@ mlx4_en_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
        int nhoff = skb_network_offset(skb);
        int ret = 0;
 
-       if (skb->protocol != htons(ETH_P_IP))
+       if (skb->protocol != cpu_to_be16(ETH_P_IP))
                return -EPROTONOSUPPORT;
 
        ip = (const struct iphdr *)(skb->data + nhoff);
@@ -328,7 +328,7 @@ mlx4_en_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
        src_port = ports[0];
        dst_port = ports[1];
 
-       spin_lock_bh(&priv->filters_lock);
+       spin_lock(&priv->filters_lock);
        filter = mlx4_en_filter_find(priv, src_ip, dst_ip, ip_proto,
                                     src_port, dst_port);
        if (filter) {
@@ -351,7 +351,7 @@ mlx4_en_filter_rfs(struct net_device *net_dev, const struct sk_buff *skb,
 out:
        ret = filter->id;
 err:
-       spin_unlock_bh(&priv->filters_lock);
+       spin_unlock(&priv->filters_lock);
 
        return ret;
 }
@@ -361,12 +361,12 @@ void mlx4_en_cleanup_filters(struct mlx4_en_priv *priv)
        struct mlx4_en_filter *filter, *tmp;
        LIST_HEAD(del_list);
 
-       spin_lock_bh(&priv->filters_lock);
+       spin_lock(&priv->filters_lock);
        list_for_each_entry_safe(filter, tmp, &priv->filters, next) {
                list_move(&filter->next, &del_list);
                hlist_del(&filter->filter_chain);
        }
-       spin_unlock_bh(&priv->filters_lock);
+       spin_unlock(&priv->filters_lock);
 
        list_for_each_entry_safe(filter, tmp, &del_list, next) {
                cancel_work_sync(&filter->work);
@@ -380,7 +380,7 @@ static void mlx4_en_filter_rfs_expire(struct mlx4_en_priv *priv)
        LIST_HEAD(del_list);
        int i = 0;
 
-       spin_lock_bh(&priv->filters_lock);
+       spin_lock(&priv->filters_lock);
        list_for_each_entry_safe(filter, tmp, &priv->filters, next) {
                if (i > MLX4_EN_FILTER_EXPIRY_QUOTA)
                        break;
@@ -401,15 +401,15 @@ static void mlx4_en_filter_rfs_expire(struct mlx4_en_priv *priv)
        if (last_filter && (&last_filter->next != priv->filters.next))
                list_move(&priv->filters, &last_filter->next);
 
-       spin_unlock_bh(&priv->filters_lock);
+       spin_unlock(&priv->filters_lock);
 
        list_for_each_entry_safe(filter, tmp, &del_list, next)
                mlx4_en_filter_free(filter);
 }
 #endif
 
-static int mlx4_en_vlan_rx_add_vid(struct net_device *dev,
-                                  __be16 proto, u16 vid)
+static int mlx4_en_vlan_rx_add_vid(struct ether *dev,
+                                  __be16 proto, uint16_t vid)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -421,7 +421,7 @@ static int mlx4_en_vlan_rx_add_vid(struct net_device *dev,
        set_bit(vid, priv->active_vlans);
 
        /* Add VID to port VLAN filter */
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (mdev->device_up && priv->port_up) {
                err = mlx4_SET_VLAN_FLTR(mdev->dev, priv);
                if (err)
@@ -429,13 +429,13 @@ static int mlx4_en_vlan_rx_add_vid(struct net_device *dev,
        }
        if (mlx4_register_vlan(mdev->dev, priv->port, vid, &idx))
                en_dbg(HW, priv, "failed adding vlan %d\n", vid);
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 
        return 0;
 }
 
-static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
-                                   __be16 proto, u16 vid)
+static int mlx4_en_vlan_rx_kill_vid(struct ether *dev,
+                                   __be16 proto, uint16_t vid)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -446,7 +446,7 @@ static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
        clear_bit(vid, priv->active_vlans);
 
        /* Remove VID from port VLAN filter */
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        mlx4_unregister_vlan(mdev->dev, priv->port, vid);
 
        if (mdev->device_up && priv->port_up) {
@@ -454,24 +454,25 @@ static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
                if (err)
                        en_err(priv, "Failed configuring VLAN filter\n");
        }
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 
        return 0;
 }
 
-static void mlx4_en_u64_to_mac(unsigned char dst_mac[ETH_ALEN + 2], u64 src_mac)
+static void mlx4_en_u64_to_mac(unsigned char dst_mac[Eaddrlen + 2],
+                              uint64_t src_mac)
 {
        int i;
-       for (i = ETH_ALEN - 1; i >= 0; --i) {
+       for (i = Eaddrlen - 1; i >= 0; --i) {
                dst_mac[i] = src_mac & 0xff;
                src_mac >>= 8;
        }
-       memset(&dst_mac[ETH_ALEN], 0, 2);
+       memset(&dst_mac[Eaddrlen], 0, 2);
 }
 
 
 static int mlx4_en_tunnel_steer_add(struct mlx4_en_priv *priv, unsigned char *addr,
-                                   int qpn, u64 *reg_id)
+                                   int qpn, uint64_t *reg_id)
 {
        int err;
 
@@ -491,7 +492,8 @@ static int mlx4_en_tunnel_steer_add(struct mlx4_en_priv *priv, unsigned char *ad
 
 
 static int mlx4_en_uc_steer_add(struct mlx4_en_priv *priv,
-                               unsigned char *mac, int *qpn, u64 *reg_id)
+                               unsigned char *mac, int *qpn,
+                               uint64_t *reg_id)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_dev *dev = mdev->dev;
@@ -500,10 +502,10 @@ static int mlx4_en_uc_steer_add(struct mlx4_en_priv *priv,
        switch (dev->caps.steering_mode) {
        case MLX4_STEERING_MODE_B0: {
                struct mlx4_qp qp;
-               u8 gid[16] = {0};
+               uint8_t gid[16] = {0};
 
                qp.qpn = *qpn;
-               memcpy(&gid[10], mac, ETH_ALEN);
+               memcpy(&gid[10], mac, Eaddrlen);
                gid[5] = priv->port;
 
                err = mlx4_unicast_attach(dev, &qp, gid, 0, MLX4_PROT_ETH);
@@ -526,8 +528,8 @@ static int mlx4_en_uc_steer_add(struct mlx4_en_priv *priv,
                INIT_LIST_HEAD(&rule.list);
 
                spec_eth.id = MLX4_NET_TRANS_RULE_ID_ETH;
-               memcpy(spec_eth.eth.dst_mac, mac, ETH_ALEN);
-               memcpy(spec_eth.eth.dst_mac_msk, &mac_mask, ETH_ALEN);
+               memcpy(spec_eth.eth.dst_mac, mac, Eaddrlen);
+               memcpy(spec_eth.eth.dst_mac_msk, &mac_mask, Eaddrlen);
                list_add_tail(&spec_eth.list, &rule.list);
 
                err = mlx4_flow_attach(dev, &rule, reg_id);
@@ -543,7 +545,8 @@ static int mlx4_en_uc_steer_add(struct mlx4_en_priv *priv,
 }
 
 static void mlx4_en_uc_steer_release(struct mlx4_en_priv *priv,
-                                    unsigned char *mac, int qpn, u64 reg_id)
+                                    unsigned char *mac, int qpn,
+                                    uint64_t reg_id)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_dev *dev = mdev->dev;
@@ -551,10 +554,10 @@ static void mlx4_en_uc_steer_release(struct mlx4_en_priv *priv,
        switch (dev->caps.steering_mode) {
        case MLX4_STEERING_MODE_B0: {
                struct mlx4_qp qp;
-               u8 gid[16] = {0};
+               uint8_t gid[16] = {0};
 
                qp.qpn = qpn;
-               memcpy(&gid[10], mac, ETH_ALEN);
+               memcpy(&gid[10], mac, Eaddrlen);
                gid[5] = priv->port;
 
                mlx4_unicast_detach(dev, &qp, gid, MLX4_PROT_ETH);
@@ -576,17 +579,17 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
        struct mlx4_mac_entry *entry;
        int index = 0;
        int err = 0;
-       u64 reg_id = 0;
+       uint64_t reg_id = 0;
        int *qpn = &priv->base_qpn;
-       u64 mac = mlx4_mac_to_u64(priv->dev->dev_addr);
+       uint64_t mac = mlx4_mac_to_u64(priv->dev->ea);
 
        en_dbg(DRV, priv, "Registering MAC: %pM for adding\n",
-              priv->dev->dev_addr);
+              priv->dev->ea);
        index = mlx4_register_mac(dev, priv->port, mac);
        if (index < 0) {
                err = index;
                en_err(priv, "Failed adding MAC: %pM\n",
-                      priv->dev->dev_addr);
+                      priv->dev->ea);
                return err;
        }
 
@@ -603,21 +606,21 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
                goto qp_err;
        }
 
-       err = mlx4_en_uc_steer_add(priv, priv->dev->dev_addr, qpn, &reg_id);
+       err = mlx4_en_uc_steer_add(priv, priv->dev->ea, qpn, &reg_id);
        if (err)
                goto steer_err;
 
-       err = mlx4_en_tunnel_steer_add(priv, priv->dev->dev_addr, *qpn,
+       err = mlx4_en_tunnel_steer_add(priv, priv->dev->ea, *qpn,
                                       &priv->tunnel_reg_id);
        if (err)
                goto tunnel_err;
 
-       entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+       entry = kmalloc(sizeof(*entry), KMALLOC_WAIT);
        if (!entry) {
                err = -ENOMEM;
                goto alloc_err;
        }
-       memcpy(entry->mac, priv->dev->dev_addr, sizeof(entry->mac));
+       memcpy(entry->mac, priv->dev->ea, sizeof(entry->mac));
        memcpy(priv->current_mac, entry->mac, sizeof(priv->current_mac));
        entry->reg_id = reg_id;
 
@@ -630,7 +633,7 @@ alloc_err:
        if (priv->tunnel_reg_id)
                mlx4_flow_detach(priv->mdev->dev, priv->tunnel_reg_id);
 tunnel_err:
-       mlx4_en_uc_steer_release(priv, priv->dev->dev_addr, *qpn, reg_id);
+       mlx4_en_uc_steer_release(priv, priv->dev->ea, *qpn, reg_id);
 
 steer_err:
        mlx4_qp_release_range(dev, *qpn, 1);
@@ -645,12 +648,12 @@ static void mlx4_en_put_qp(struct mlx4_en_priv *priv)
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_dev *dev = mdev->dev;
        int qpn = priv->base_qpn;
-       u64 mac;
+       uint64_t mac;
 
        if (dev->caps.steering_mode == MLX4_STEERING_MODE_A0) {
-               mac = mlx4_mac_to_u64(priv->dev->dev_addr);
+               mac = mlx4_mac_to_u64(priv->dev->ea);
                en_dbg(DRV, priv, "Registering MAC: %pM for deleting\n",
-                      priv->dev->dev_addr);
+                      priv->dev->ea);
                mlx4_unregister_mac(dev, priv->port, mac);
        } else {
                struct mlx4_mac_entry *entry;
@@ -691,14 +694,14 @@ static int mlx4_en_replace_mac(struct mlx4_en_priv *priv, int qpn,
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_dev *dev = mdev->dev;
        int err = 0;
-       u64 new_mac_u64 = mlx4_mac_to_u64(new_mac);
+       uint64_t new_mac_u64 = mlx4_mac_to_u64(new_mac);
 
        if (dev->caps.steering_mode != MLX4_STEERING_MODE_A0) {
                struct hlist_head *bucket;
                unsigned int mac_hash;
                struct mlx4_mac_entry *entry;
                struct hlist_node *tmp;
-               u64 prev_mac_u64 = mlx4_mac_to_u64(prev_mac);
+               uint64_t prev_mac_u64 = mlx4_mac_to_u64(prev_mac);
 
                bucket = &priv->mac_hash[prev_mac[MLX4_EN_MAC_HASH_IDX]];
                hlist_for_each_entry_safe(entry, tmp, bucket, hlist) {
@@ -709,7 +712,7 @@ static int mlx4_en_replace_mac(struct mlx4_en_priv *priv, int qpn,
                                                    prev_mac_u64);
                                hlist_del_rcu(&entry->hlist);
                                synchronize_rcu();
-                               memcpy(entry->mac, new_mac, ETH_ALEN);
+                               memcpy(entry->mac, new_mac, Eaddrlen);
                                entry->reg_id = 0;
                                mac_hash = new_mac[MLX4_EN_MAC_HASH_IDX];
                                hlist_add_head_rcu(&entry->hlist,
@@ -736,7 +739,7 @@ static int mlx4_en_replace_mac(struct mlx4_en_priv *priv, int qpn,
 }
 
 static int mlx4_en_do_set_mac(struct mlx4_en_priv *priv,
-                             unsigned char new_mac[ETH_ALEN + 2])
+                             unsigned char new_mac[Eaddrlen + 2])
 {
        int err = 0;
 
@@ -755,28 +758,28 @@ static int mlx4_en_do_set_mac(struct mlx4_en_priv *priv,
        return err;
 }
 
-static int mlx4_en_set_mac(struct net_device *dev, void *addr)
+static int mlx4_en_set_mac(struct ether *dev, void *addr)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        struct sockaddr *saddr = addr;
-       unsigned char new_mac[ETH_ALEN + 2];
+       unsigned char new_mac[Eaddrlen + 2];
        int err;
 
        if (!is_valid_ether_addr(saddr->sa_data))
                return -EADDRNOTAVAIL;
 
-       mutex_lock(&mdev->state_lock);
-       memcpy(new_mac, saddr->sa_data, ETH_ALEN);
+       qlock(&mdev->state_lock);
+       memcpy(new_mac, saddr->sa_data, Eaddrlen);
        err = mlx4_en_do_set_mac(priv, new_mac);
        if (!err)
-               memcpy(dev->dev_addr, saddr->sa_data, ETH_ALEN);
-       mutex_unlock(&mdev->state_lock);
+               memcpy(dev->ea, saddr->sa_data, Eaddrlen);
+       qunlock(&mdev->state_lock);
 
        return err;
 }
 
-static void mlx4_en_clear_list(struct net_device *dev)
+static void mlx4_en_clear_list(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_mc_list *tmp, *mc_to_del;
@@ -787,7 +790,7 @@ static void mlx4_en_clear_list(struct net_device *dev)
        }
 }
 
-static void mlx4_en_cache_mclist(struct net_device *dev)
+static void mlx4_en_cache_mclist(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct netdev_hw_addr *ha;
@@ -795,12 +798,12 @@ static void mlx4_en_cache_mclist(struct net_device *dev)
 
        mlx4_en_clear_list(dev);
        netdev_for_each_mc_addr(ha, dev) {
-               tmp = kzalloc(sizeof(struct mlx4_en_mc_list), GFP_ATOMIC);
+               tmp = kzmalloc(sizeof(struct mlx4_en_mc_list), 0);
                if (!tmp) {
                        mlx4_en_clear_list(dev);
                        return;
                }
-               memcpy(tmp->addr, ha->addr, ETH_ALEN);
+               memcpy(tmp->addr, ha->addr, Eaddrlen);
                list_add_tail(&tmp->list, &priv->mc_list);
        }
 }
@@ -842,7 +845,7 @@ static void update_mclist_flags(struct mlx4_en_priv *priv,
                if (!found) {
                        new_mc = kmemdup(src_tmp,
                                         sizeof(struct mlx4_en_mc_list),
-                                        GFP_KERNEL);
+                                        KMALLOC_WAIT);
                        if (!new_mc)
                                return;
 
@@ -852,7 +855,7 @@ static void update_mclist_flags(struct mlx4_en_priv *priv,
        }
 }
 
-static void mlx4_en_set_rx_mode(struct net_device *dev)
+static void mlx4_en_set_rx_mode(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
@@ -970,12 +973,12 @@ static void mlx4_en_clear_promisc_mode(struct mlx4_en_priv *priv,
 }
 
 static void mlx4_en_do_multicast(struct mlx4_en_priv *priv,
-                                struct net_device *dev,
+                                struct ether *dev,
                                 struct mlx4_en_dev *mdev)
 {
        struct mlx4_en_mc_list *mclist, *tmp;
-       u64 mcast_addr = 0;
-       u8 mc_list[16] = {0};
+       uint64_t mcast_addr = 0;
+       uint8_t mc_list[16] = {0};
        int err = 0;
 
        /* Enable/disable the multicast filter according to IFF_ALLMULTI */
@@ -1043,9 +1046,9 @@ static void mlx4_en_do_multicast(struct mlx4_en_priv *priv,
 
                /* Update multicast list - we cache all addresses so they won't
                 * change while HW is updated holding the command semaphor */
-               netif_addr_lock_bh(dev);
+               qlock(&dev->qlock);
                mlx4_en_cache_mclist(dev);
-               netif_addr_unlock_bh(dev);
+               qunlock(&dev->qlock);
                list_for_each_entry(mclist, &priv->mc_list, list) {
                        mcast_addr = mlx4_mac_to_u64(mclist->addr);
                        mlx4_SET_MCAST_FLTR(mdev->dev, priv->port,
@@ -1060,7 +1063,7 @@ static void mlx4_en_do_multicast(struct mlx4_en_priv *priv,
                list_for_each_entry_safe(mclist, tmp, &priv->curr_list, list) {
                        if (mclist->action == MCLIST_REM) {
                                /* detach this address and delete from list */
-                               memcpy(&mc_list[10], mclist->addr, ETH_ALEN);
+                               memcpy(&mc_list[10], mclist->addr, Eaddrlen);
                                mc_list[5] = priv->port;
                                err = mlx4_multicast_detach(mdev->dev,
                                                            &priv->rss_map.indir_qp,
@@ -1081,7 +1084,7 @@ static void mlx4_en_do_multicast(struct mlx4_en_priv *priv,
                                kfree(mclist);
                        } else if (mclist->action == MCLIST_ADD) {
                                /* attach the address */
-                               memcpy(&mc_list[10], mclist->addr, ETH_ALEN);
+                               memcpy(&mc_list[10], mclist->addr, Eaddrlen);
                                /* needed for B0 steering support */
                                mc_list[5] = priv->port;
                                err = mlx4_multicast_attach(mdev->dev,
@@ -1103,19 +1106,19 @@ static void mlx4_en_do_multicast(struct mlx4_en_priv *priv,
 }
 
 static void mlx4_en_do_uc_filter(struct mlx4_en_priv *priv,
-                                struct net_device *dev,
+                                struct ether *dev,
                                 struct mlx4_en_dev *mdev)
 {
        struct netdev_hw_addr *ha;
        struct mlx4_mac_entry *entry;
        struct hlist_node *tmp;
        bool found;
-       u64 mac;
+       uint64_t mac;
        int err = 0;
        struct hlist_head *bucket;
        unsigned int i;
        int removed = 0;
-       u32 prev_flags;
+       uint32_t prev_flags;
 
        /* Note that we do not need to protect our mac_hash traversal with rcu,
         * since all modification code is protected by mdev->state_lock
@@ -1176,7 +1179,7 @@ static void mlx4_en_do_uc_filter(struct mlx4_en_priv *priv,
                }
 
                if (!found) {
-                       entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+                       entry = kmalloc(sizeof(*entry), KMALLOC_WAIT);
                        if (!entry) {
                                en_err(priv, "Failed adding MAC %pM on port:%d (out of memory)\n",
                                       ha->addr, priv->port);
@@ -1184,7 +1187,7 @@ static void mlx4_en_do_uc_filter(struct mlx4_en_priv *priv,
                                break;
                        }
                        mac = mlx4_mac_to_u64(ha->addr);
-                       memcpy(entry->mac, ha->addr, ETH_ALEN);
+                       memcpy(entry->mac, ha->addr, Eaddrlen);
                        err = mlx4_register_mac(mdev->dev, priv->port, mac);
                        if (err < 0) {
                                en_err(priv, "Failed registering MAC %pM on port %d: %d\n",
@@ -1228,9 +1231,9 @@ static void mlx4_en_do_set_rx_mode(struct work_struct *work)
        struct mlx4_en_priv *priv = container_of(work, struct mlx4_en_priv,
                                                 rx_mode_task);
        struct mlx4_en_dev *mdev = priv->mdev;
-       struct net_device *dev = priv->dev;
+       struct ether *dev = priv->dev;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (!mdev->device_up) {
                en_dbg(HW, priv, "Card is not up, ignoring rx mode change.\n");
                goto out;
@@ -1266,11 +1269,11 @@ static void mlx4_en_do_set_rx_mode(struct work_struct *work)
 
        mlx4_en_do_multicast(priv, dev, mdev);
 out:
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 }
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
-static void mlx4_en_netpoll(struct net_device *dev)
+static void mlx4_en_netpoll(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_cq *cq;
@@ -1283,7 +1286,7 @@ static void mlx4_en_netpoll(struct net_device *dev)
 }
 #endif
 
-static void mlx4_en_tx_timeout(struct net_device *dev)
+static void mlx4_en_tx_timeout(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1306,13 +1309,13 @@ static void mlx4_en_tx_timeout(struct net_device *dev)
 }
 
 
-static struct net_device_stats *mlx4_en_get_stats(struct net_device *dev)
+static struct net_device_stats *mlx4_en_get_stats(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
-       spin_lock_bh(&priv->stats_lock);
+       spin_lock(&priv->stats_lock);
        memcpy(&priv->ret_stats, &priv->stats, sizeof(priv->stats));
-       spin_unlock_bh(&priv->stats_lock);
+       spin_unlock(&priv->stats_lock);
 
        return &priv->ret_stats;
 }
@@ -1333,7 +1336,7 @@ static void mlx4_en_set_default_moderation(struct mlx4_en_priv *priv)
        priv->tx_frames = MLX4_EN_TX_COAL_PKTS;
        priv->tx_usecs = MLX4_EN_TX_COAL_TIME;
        en_dbg(INTR, priv, "Default coalesing params for mtu:%d - rx_frames:%d rx_usecs:%d\n",
-              priv->dev->mtu, priv->rx_frames, priv->rx_usecs);
+              priv->dev->maxmtu, priv->rx_frames, priv->rx_usecs);
 
        /* Setup cq moderation params */
        for (i = 0; i < priv->rx_ring_num; i++) {
@@ -1379,10 +1382,10 @@ static void mlx4_en_auto_moderation(struct mlx4_en_priv *priv)
                return;
 
        for (ring = 0; ring < priv->rx_ring_num; ring++) {
-               spin_lock_bh(&priv->stats_lock);
+               spin_lock(&priv->stats_lock);
                rx_packets = priv->rx_ring[ring]->packets;
                rx_bytes = priv->rx_ring[ring]->bytes;
-               spin_unlock_bh(&priv->stats_lock);
+               spin_unlock(&priv->stats_lock);
 
                rx_pkt_diff = ((unsigned long) (rx_packets -
                                priv->last_moder_packets[ring]));
@@ -1433,7 +1436,7 @@ static void mlx4_en_do_get_stats(struct work_struct *work)
        struct mlx4_en_dev *mdev = priv->mdev;
        int err;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (mdev->device_up) {
                if (priv->port_up) {
                        err = mlx4_en_DUMP_ETH_STATS(mdev, priv->port, 0);
@@ -1449,7 +1452,7 @@ static void mlx4_en_do_get_stats(struct work_struct *work)
                mlx4_en_do_set_mac(priv, priv->current_mac);
                mdev->mac_removed[MLX4_MAX_PORTS + 1 - priv->port] = 0;
        }
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 }
 
 /* mlx4_en_service_task - Run service task for tasks that needed to be done
@@ -1462,7 +1465,7 @@ static void mlx4_en_service_task(struct work_struct *work)
                                                 service_task);
        struct mlx4_en_dev *mdev = priv->mdev;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (mdev->device_up) {
                if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_TS)
                        mlx4_en_ptp_overflow_check(mdev);
@@ -1471,7 +1474,7 @@ static void mlx4_en_service_task(struct work_struct *work)
                queue_delayed_work(mdev->workqueue, &priv->service_task,
                                   SERVICE_TASK_DELAY);
        }
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 }
 
 static void mlx4_en_linkstate(struct work_struct *work)
@@ -1481,7 +1484,7 @@ static void mlx4_en_linkstate(struct work_struct *work)
        struct mlx4_en_dev *mdev = priv->mdev;
        int linkstate = priv->link_state;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        /* If observable port state changed set carrier state and
         * report to system log */
        if (priv->last_link_state != linkstate) {
@@ -1494,7 +1497,7 @@ static void mlx4_en_linkstate(struct work_struct *work)
                }
        }
        priv->last_link_state = linkstate;
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 }
 
 static int mlx4_en_init_affinity_hint(struct mlx4_en_priv *priv, int ring_idx)
@@ -1502,7 +1505,7 @@ static int mlx4_en_init_affinity_hint(struct mlx4_en_priv *priv, int ring_idx)
        struct mlx4_en_rx_ring *ring = priv->rx_ring[ring_idx];
        int numa_node = priv->mdev->dev->numa_node;
 
-       if (!zalloc_cpumask_var(&ring->affinity_mask, GFP_KERNEL))
+       if (!zalloc_cpumask_var(&ring->affinity_mask, KMALLOC_WAIT))
                return -ENOMEM;
 
        cpumask_set_cpu(cpumask_local_spread(ring_idx, numa_node),
@@ -1515,7 +1518,7 @@ static void mlx4_en_free_affinity_hint(struct mlx4_en_priv *priv, int ring_idx)
        free_cpumask_var(priv->rx_ring[ring_idx]->affinity_mask);
 }
 
-int mlx4_en_start_port(struct net_device *dev)
+int mlx4_en_start_port(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1526,7 +1529,7 @@ int mlx4_en_start_port(struct net_device *dev)
        int err = 0;
        int i;
        int j;
-       u8 mc_list[16] = {0};
+       uint8_t mc_list[16] = {0};
 
        if (priv->port_up) {
                en_dbg(DRV, priv, "start port called while port already up\n");
@@ -1540,7 +1543,7 @@ int mlx4_en_start_port(struct net_device *dev)
               sizeof(struct ethtool_flow_id) * MAX_NUM_OF_FS_RULES);
 
        /* Calculate Rx buf size */
-       dev->mtu = min(dev->mtu, priv->max_mtu);
+       dev->maxmtu = MIN(dev->maxmtu, priv->max_mtu);
        mlx4_en_calc_rx_buf(dev);
        en_dbg(DRV, priv, "Rx buf size:%d\n", priv->rx_skb_size);
 
@@ -1641,7 +1644,7 @@ int mlx4_en_start_port(struct net_device *dev)
 
                /* Set initial ownership of all Tx TXBBs to SW (1) */
                for (j = 0; j < tx_ring->buf_size; j += STAMP_STRIDE)
-                       *((u32 *) (tx_ring->buf + j)) = 0xffffffff;
+                       *((uint32_t *) (tx_ring->buf + j)) = 0xffffffff;
                ++tx_index;
        }
 
@@ -1727,14 +1730,14 @@ cq_err:
 }
 
 
-void mlx4_en_stop_port(struct net_device *dev, int detach)
+void mlx4_en_stop_port(struct ether *dev, int detach)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_mc_list *mclist, *tmp;
        struct ethtool_flow_id *flow, *tmp_flow;
        int i;
-       u8 mc_list[16] = {0};
+       uint8_t mc_list[16] = {0};
 
        if (!priv->port_up) {
                en_dbg(DRV, priv, "stop port called while port already down\n");
@@ -1788,7 +1791,7 @@ void mlx4_en_stop_port(struct net_device *dev, int detach)
        mlx4_multicast_detach(mdev->dev, &priv->rss_map.indir_qp, mc_list,
                              MLX4_PROT_ETH, priv->broadcast_id);
        list_for_each_entry(mclist, &priv->curr_list, list) {
-               memcpy(&mc_list[10], mclist->addr, ETH_ALEN);
+               memcpy(&mc_list[10], mclist->addr, Eaddrlen);
                mc_list[5] = priv->port;
                mlx4_multicast_detach(mdev->dev, &priv->rss_map.indir_qp,
                                      mc_list, MLX4_PROT_ETH, mclist->reg_id);
@@ -1822,7 +1825,7 @@ void mlx4_en_stop_port(struct net_device *dev, int detach)
                mlx4_en_deactivate_tx_ring(priv, priv->tx_ring[i]);
                mlx4_en_deactivate_cq(priv, priv->tx_cq[i]);
        }
-       msleep(10);
+       kthread_usleep(1000 * 10);
 
        for (i = 0; i < priv->tx_ring_num; i++)
                mlx4_en_free_tx_buf(dev, priv->tx_ring[i]);
@@ -1859,20 +1862,20 @@ static void mlx4_en_restart(struct work_struct *work)
        struct mlx4_en_priv *priv = container_of(work, struct mlx4_en_priv,
                                                 watchdog_task);
        struct mlx4_en_dev *mdev = priv->mdev;
-       struct net_device *dev = priv->dev;
+       struct ether *dev = priv->dev;
 
        en_dbg(DRV, priv, "Watchdog task called for port %d\n", priv->port);
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (priv->port_up) {
                mlx4_en_stop_port(dev, 1);
                if (mlx4_en_start_port(dev))
                        en_err(priv, "Failed restarting port %d\n", priv->port);
        }
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 }
 
-static void mlx4_en_clear_stats(struct net_device *dev)
+static void mlx4_en_clear_stats(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -1906,13 +1909,13 @@ static void mlx4_en_clear_stats(struct net_device *dev)
        }
 }
 
-static int mlx4_en_open(struct net_device *dev)
+static int mlx4_en_open(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        int err = 0;
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
 
        if (!mdev->device_up) {
                en_err(priv, "Cannot open - device down/disabled\n");
@@ -1928,24 +1931,24 @@ static int mlx4_en_open(struct net_device *dev)
                en_err(priv, "Failed starting port:%d\n", priv->port);
 
 out:
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
        return err;
 }
 
 
-static int mlx4_en_close(struct net_device *dev)
+static int mlx4_en_close(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
 
        en_dbg(IFDOWN, priv, "Close port called\n");
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
 
        mlx4_en_stop_port(dev, 0);
        netif_carrier_off(dev);
 
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
        return 0;
 }
 
@@ -2041,7 +2044,7 @@ err:
 }
 
 
-void mlx4_en_destroy_netdev(struct net_device *dev)
+void mlx4_en_destroy_netdev(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -2061,10 +2064,10 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
        flush_workqueue(mdev->workqueue);
 
        /* Detach the netdev so tasks would not attempt to access it */
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        mdev->pndev[priv->port] = NULL;
        mdev->upper[priv->port] = NULL;
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
 
        mlx4_en_free_resources(priv);
 
@@ -2074,23 +2077,23 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
        free_netdev(dev);
 }
 
-static int mlx4_en_change_mtu(struct net_device *dev, int new_mtu)
+static int mlx4_en_change_mtu(struct ether *dev, int new_mtu)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        int err = 0;
 
        en_dbg(DRV, priv, "Change MTU called - current:%d new:%d\n",
-                dev->mtu, new_mtu);
+                dev->maxmtu, new_mtu);
 
        if ((new_mtu < MLX4_EN_MIN_MTU) || (new_mtu > priv->max_mtu)) {
                en_err(priv, "Bad MTU size:%d.\n", new_mtu);
                return -EPERM;
        }
-       dev->mtu = new_mtu;
+       dev->maxmtu = new_mtu;
 
        if (netif_running(dev)) {
-               mutex_lock(&mdev->state_lock);
+               qlock(&mdev->state_lock);
                if (!mdev->device_up) {
                        /* NIC is probably restarting - let watchdog task reset
                         * the port */
@@ -2104,18 +2107,18 @@ static int mlx4_en_change_mtu(struct net_device *dev, int new_mtu)
                                queue_work(mdev->workqueue, &priv->watchdog_task);
                        }
                }
-               mutex_unlock(&mdev->state_lock);
+               qunlock(&mdev->state_lock);
        }
        return 0;
 }
 
-static int mlx4_en_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
+static int mlx4_en_hwtstamp_set(struct ether *dev, struct ifreq *ifr)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        struct hwtstamp_config config;
 
-       if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
+       if (memcpy_from_user(current, &config, ifr->ifr_data, sizeof(config)))
                return -EFAULT;
 
        /* reserved for future extensions */
@@ -2159,24 +2162,23 @@ static int mlx4_en_hwtstamp_set(struct net_device *dev, struct ifreq *ifr)
                return -ERANGE;
        }
 
-       if (mlx4_en_reset_config(dev, config, dev->features)) {
+       if (mlx4_en_reset_config(dev, config, dev->feat)) {
                config.tx_type = HWTSTAMP_TX_OFF;
                config.rx_filter = HWTSTAMP_FILTER_NONE;
        }
 
-       return copy_to_user(ifr->ifr_data, &config,
-                           sizeof(config)) ? -EFAULT : 0;
+       return memcpy_to_user(current, ifr->ifr_data, &config, sizeof(config)) ? -EFAULT : 0;
 }
 
-static int mlx4_en_hwtstamp_get(struct net_device *dev, struct ifreq *ifr)
+static int mlx4_en_hwtstamp_get(struct ether *dev, struct ifreq *ifr)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
 
-       return copy_to_user(ifr->ifr_data, &priv->hwtstamp_config,
-                           sizeof(priv->hwtstamp_config)) ? -EFAULT : 0;
+       return memcpy_to_user(current, ifr->ifr_data, &priv->hwtstamp_config,
+                             sizeof(priv->hwtstamp_config)) ? -EFAULT : 0;
 }
 
-static int mlx4_en_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+static int mlx4_en_ioctl(struct ether *dev, struct ifreq *ifr, int cmd)
 {
        switch (cmd) {
        case SIOCSHWTSTAMP:
@@ -2188,8 +2190,8 @@ static int mlx4_en_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
        }
 }
 
-static int mlx4_en_set_features(struct net_device *netdev,
-               netdev_features_t features)
+static int mlx4_en_set_features(struct ether *netdev,
+                               netdev_features_t features)
 {
        struct mlx4_en_priv *priv = netdev_priv(netdev);
        bool reset = false;
@@ -2202,7 +2204,7 @@ static int mlx4_en_set_features(struct net_device *netdev,
        }
 
        if (DEV_FEATURE_CHANGED(netdev, features, NETIF_F_RXALL)) {
-               u8 ignore_fcs_value = (features & NETIF_F_RXALL) ? 1 : 0;
+               uint8_t ignore_fcs_value = (features & NETIF_F_RXALL) ? 1 : 0;
 
                en_info(priv, "Turn %s RX-ALL\n",
                        ignore_fcs_value ? "ON" : "OFF");
@@ -2238,11 +2240,11 @@ static int mlx4_en_set_features(struct net_device *netdev,
        return 0;
 }
 
-static int mlx4_en_set_vf_mac(struct net_device *dev, int queue, u8 *mac)
+static int mlx4_en_set_vf_mac(struct ether *dev, int queue, uint8_t *mac)
 {
        struct mlx4_en_priv *en_priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = en_priv->mdev;
-       u64 mac_u64 = mlx4_mac_to_u64(mac);
+       uint64_t mac_u64 = mlx4_mac_to_u64(mac);
 
        if (!is_valid_ether_addr(mac))
                return -EINVAL;
@@ -2250,7 +2252,8 @@ static int mlx4_en_set_vf_mac(struct net_device *dev, int queue, u8 *mac)
        return mlx4_set_vf_mac(mdev->dev, en_priv->port, queue, mac_u64);
 }
 
-static int mlx4_en_set_vf_vlan(struct net_device *dev, int vf, u16 vlan, u8 qos)
+static int mlx4_en_set_vf_vlan(struct ether *dev, int vf, uint16_t vlan,
+                              uint8_t qos)
 {
        struct mlx4_en_priv *en_priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = en_priv->mdev;
@@ -2258,7 +2261,7 @@ static int mlx4_en_set_vf_vlan(struct net_device *dev, int vf, u16 vlan, u8 qos)
        return mlx4_set_vf_vlan(mdev->dev, en_priv->port, vf, vlan, qos);
 }
 
-static int mlx4_en_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
+static int mlx4_en_set_vf_rate(struct ether *dev, int vf, int min_tx_rate,
                               int max_tx_rate)
 {
        struct mlx4_en_priv *en_priv = netdev_priv(dev);
@@ -2268,7 +2271,7 @@ static int mlx4_en_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
                                max_tx_rate);
 }
 
-static int mlx4_en_set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
+static int mlx4_en_set_vf_spoofchk(struct ether *dev, int vf, bool setting)
 {
        struct mlx4_en_priv *en_priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = en_priv->mdev;
@@ -2276,7 +2279,8 @@ static int mlx4_en_set_vf_spoofchk(struct net_device *dev, int vf, bool setting)
        return mlx4_set_vf_spoofchk(mdev->dev, en_priv->port, vf, setting);
 }
 
-static int mlx4_en_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivf)
+static int mlx4_en_get_vf_config(struct ether *dev, int vf,
+                                struct ifla_vf_info *ivf)
 {
        struct mlx4_en_priv *en_priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = en_priv->mdev;
@@ -2284,7 +2288,8 @@ static int mlx4_en_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_
        return mlx4_get_vf_config(mdev->dev, en_priv->port, vf, ivf);
 }
 
-static int mlx4_en_set_vf_link_state(struct net_device *dev, int vf, int link_state)
+static int mlx4_en_set_vf_link_state(struct ether *dev, int vf,
+                                    int link_state)
 {
        struct mlx4_en_priv *en_priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = en_priv->mdev;
@@ -2293,13 +2298,13 @@ static int mlx4_en_set_vf_link_state(struct net_device *dev, int vf, int link_st
 }
 
 #define PORT_ID_BYTE_LEN 8
-static int mlx4_en_get_phys_port_id(struct net_device *dev,
+static int mlx4_en_get_phys_port_id(struct ether *dev,
                                    struct netdev_phys_item_id *ppid)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_dev *mdev = priv->mdev->dev;
        int i;
-       u64 phys_port_id = mdev->caps.phys_port_id[priv->port];
+       uint64_t phys_port_id = mdev->caps.phys_port_id[priv->port];
 
        if (!phys_port_id)
                return -EOPNOTSUPP;
@@ -2335,7 +2340,7 @@ out:
        priv->dev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
                                      NETIF_F_TSO | NETIF_F_GSO_UDP_TUNNEL;
        priv->dev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
-       priv->dev->features    |= NETIF_F_GSO_UDP_TUNNEL;
+       priv->dev->feat    |= NETIF_F_GSO_UDP_TUNNEL;
 }
 
 static void mlx4_en_del_vxlan_offloads(struct work_struct *work)
@@ -2347,7 +2352,7 @@ static void mlx4_en_del_vxlan_offloads(struct work_struct *work)
        priv->dev->hw_enc_features &= ~(NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
                                      NETIF_F_TSO | NETIF_F_GSO_UDP_TUNNEL);
        priv->dev->hw_features &= ~NETIF_F_GSO_UDP_TUNNEL;
-       priv->dev->features    &= ~NETIF_F_GSO_UDP_TUNNEL;
+       priv->dev->feat    &= ~NETIF_F_GSO_UDP_TUNNEL;
 
        ret = mlx4_SET_PORT_VXLAN(priv->mdev->dev, priv->port,
                                  VXLAN_STEER_BY_OUTER_MAC, 0);
@@ -2357,7 +2362,7 @@ static void mlx4_en_del_vxlan_offloads(struct work_struct *work)
        priv->vxlan_port = 0;
 }
 
-static void mlx4_en_add_vxlan_port(struct  net_device *dev,
+static void mlx4_en_add_vxlan_port(struct  ether *dev,
                                   sa_family_t sa_family, __be16 port)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -2372,7 +2377,7 @@ static void mlx4_en_add_vxlan_port(struct  net_device *dev,
        current_port = priv->vxlan_port;
        if (current_port && current_port != port) {
                en_warn(priv, "vxlan port %d configured, can't add port %d\n",
-                       ntohs(current_port), ntohs(port));
+                       be16_to_cpu(current_port), be16_to_cpu(port));
                return;
        }
 
@@ -2380,7 +2385,7 @@ static void mlx4_en_add_vxlan_port(struct  net_device *dev,
        queue_work(priv->mdev->workqueue, &priv->vxlan_add_task);
 }
 
-static void mlx4_en_del_vxlan_port(struct  net_device *dev,
+static void mlx4_en_del_vxlan_port(struct  ether *dev,
                                   sa_family_t sa_family, __be16 port)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -2394,7 +2399,8 @@ static void mlx4_en_del_vxlan_port(struct  net_device *dev,
 
        current_port = priv->vxlan_port;
        if (current_port != port) {
-               en_dbg(DRV, priv, "vxlan port %d isn't configured, ignoring\n", ntohs(port));
+               en_dbg(DRV, priv, "vxlan port %d isn't configured, ignoring\n",
+                      be16_to_cpu(port));
                return;
        }
 
@@ -2402,7 +2408,7 @@ static void mlx4_en_del_vxlan_port(struct  net_device *dev,
 }
 
 static netdev_features_t mlx4_en_features_check(struct sk_buff *skb,
-                                               struct net_device *dev,
+                                               struct ether *dev,
                                                netdev_features_t features)
 {
        features = vlan_features_check(skb, features);
@@ -2410,7 +2416,8 @@ static netdev_features_t mlx4_en_features_check(struct sk_buff *skb,
 }
 #endif
 
-static int mlx4_en_set_tx_maxrate(struct net_device *dev, int queue_index, u32 maxrate)
+static int mlx4_en_set_tx_maxrate(struct ether *dev, int queue_index,
+                                 uint32_t maxrate)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_tx_ring *tx_ring = priv->tx_ring[queue_index];
@@ -2546,11 +2553,11 @@ static void mlx4_en_bond_work(struct work_struct *work)
 }
 
 static int mlx4_en_queue_bond_work(struct mlx4_en_priv *priv, int is_bonded,
-                                  u8 v2p_p1, u8 v2p_p2)
+                                  uint8_t v2p_p1, uint8_t v2p_p2)
 {
        struct mlx4_en_bond *bond = NULL;
 
-       bond = kzalloc(sizeof(*bond), GFP_ATOMIC);
+       bond = kzmalloc(sizeof(*bond), 0);
        if (!bond)
                return -ENOMEM;
 
@@ -2567,15 +2574,15 @@ static int mlx4_en_queue_bond_work(struct mlx4_en_priv *priv, int is_bonded,
 int mlx4_en_netdev_event(struct notifier_block *this,
                         unsigned long event, void *ptr)
 {
-       struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
-       u8 port = 0;
+       struct ether *ndev = netdev_notifier_info_to_dev(ptr);
+       uint8_t port = 0;
        struct mlx4_en_dev *mdev;
        struct mlx4_dev *dev;
        int i, num_eth_ports = 0;
        bool do_bond = true;
        struct mlx4_en_priv *priv;
-       u8 v2p_port1 = 0;
-       u8 v2p_port2 = 0;
+       uint8_t v2p_port1 = 0;
+       uint8_t v2p_port2 = 0;
 
        if (!net_eq(dev_net(ndev), &init_net))
                return NOTIFY_DONE;
@@ -2683,14 +2690,14 @@ int mlx4_en_netdev_event(struct notifier_block *this,
 
 void mlx4_en_update_pfc_stats_bitmap(struct mlx4_dev *dev,
                                     struct mlx4_en_stats_bitmap *stats_bitmap,
-                                    u8 rx_ppp, u8 rx_pause,
-                                    u8 tx_ppp, u8 tx_pause)
+                                    uint8_t rx_ppp, uint8_t rx_pause,
+                                    uint8_t tx_ppp, uint8_t tx_pause)
 {
        int last_i = NUM_MAIN_STATS + NUM_PORT_STATS;
 
        if (!mlx4_is_slave(dev) &&
            (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_FLOWSTATS_EN)) {
-               mutex_lock(&stats_bitmap->mutex);
+               qlock(&stats_bitmap->mutex);
                bitmap_clear(stats_bitmap->bitmap, last_i, NUM_FLOW_STATS);
 
                if (rx_ppp)
@@ -2713,18 +2720,18 @@ void mlx4_en_update_pfc_stats_bitmap(struct mlx4_dev *dev,
                                   NUM_FLOW_STATS_TX);
                last_i += NUM_FLOW_STATS_TX;
 
-               mutex_unlock(&stats_bitmap->mutex);
+               qunlock(&stats_bitmap->mutex);
        }
 }
 
 void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,
                              struct mlx4_en_stats_bitmap *stats_bitmap,
-                             u8 rx_ppp, u8 rx_pause,
-                             u8 tx_ppp, u8 tx_pause)
+                             uint8_t rx_ppp, uint8_t rx_pause,
+                             uint8_t tx_ppp, uint8_t tx_pause)
 {
        int last_i = 0;
 
-       mutex_init(&stats_bitmap->mutex);
+       qlock_init(&stats_bitmap->mutex);
        bitmap_zero(stats_bitmap->bitmap, NUM_ALL_STATS);
 
        if (mlx4_is_slave(dev)) {
@@ -2760,11 +2767,11 @@ void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,
 int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                        struct mlx4_en_port_profile *prof)
 {
-       struct net_device *dev;
+       struct ether *dev;
        struct mlx4_en_priv *priv;
        int i;
        int err;
-       u64 mac_u64;
+       uint64_t mac_u64;
 
        dev = alloc_etherdev_mqs(sizeof(struct mlx4_en_priv),
                                 MAX_TX_RINGS, MAX_RX_RINGS);
@@ -2775,7 +2782,6 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        netif_set_real_num_rx_queues(dev, prof->rx_ring_num);
 
        SET_NETDEV_DEV(dev, &mdev->dev->persist->pdev->dev);
-       dev->dev_port = port - 1;
 
        /*
         * Initialize driver private data
@@ -2783,7 +2789,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
 
        priv = netdev_priv(dev);
        memset(priv, 0, sizeof(struct mlx4_en_priv));
-       spin_lock_init(&priv->stats_lock);
+       spinlock_init_irqsave(&priv->stats_lock);
        INIT_WORK(&priv->rx_mode_task, mlx4_en_do_set_rx_mode);
        INIT_WORK(&priv->watchdog_task, mlx4_en_restart);
        INIT_WORK(&priv->linkstate_task, mlx4_en_linkstate);
@@ -2795,7 +2801,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
 #endif
 #ifdef CONFIG_RFS_ACCEL
        INIT_LIST_HEAD(&priv->filters);
-       spin_lock_init(&priv->filters_lock);
+       spinlock_init_irqsave(&priv->filters_lock);
 #endif
 
        priv->dev = dev;
@@ -2813,14 +2819,14 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        priv->tx_work_limit = MLX4_EN_DEFAULT_TX_WORK;
        netdev_rss_key_fill(priv->rss_key, sizeof(priv->rss_key));
 
-       priv->tx_ring = kzalloc(sizeof(struct mlx4_en_tx_ring *) * MAX_TX_RINGS,
-                               GFP_KERNEL);
+       priv->tx_ring = kzmalloc(sizeof(struct mlx4_en_tx_ring *) * MAX_TX_RINGS,
+                                KMALLOC_WAIT);
        if (!priv->tx_ring) {
                err = -ENOMEM;
                goto out;
        }
-       priv->tx_cq = kzalloc(sizeof(struct mlx4_en_cq *) * MAX_TX_RINGS,
-                             GFP_KERNEL);
+       priv->tx_cq = kzmalloc(sizeof(struct mlx4_en_cq *) * MAX_TX_RINGS,
+                              KMALLOC_WAIT);
        if (!priv->tx_cq) {
                err = -ENOMEM;
                goto out;
@@ -2852,26 +2858,25 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                priv->flags |= MLX4_EN_FLAG_RX_CSUM_NON_TCP_UDP;
 
        /* Set default MAC */
-       dev->addr_len = ETH_ALEN;
-       mlx4_en_u64_to_mac(dev->dev_addr, mdev->dev->caps.def_mac[priv->port]);
-       if (!is_valid_ether_addr(dev->dev_addr)) {
+       mlx4_en_u64_to_mac(dev->ea, mdev->dev->caps.def_mac[priv->port]);
+       if (!is_valid_ether_addr(dev->ea)) {
                if (mlx4_is_slave(priv->mdev->dev)) {
                        eth_hw_addr_random(dev);
-                       en_warn(priv, "Assigned random MAC address %pM\n", dev->dev_addr);
-                       mac_u64 = mlx4_mac_to_u64(dev->dev_addr);
+                       en_warn(priv, "Assigned random MAC address %pM\n",
+                               dev->ea);
+                       mac_u64 = mlx4_mac_to_u64(dev->ea);
                        mdev->dev->caps.def_mac[priv->port] = mac_u64;
                } else {
                        en_err(priv, "Port: %d, invalid mac burned: %pM, quiting\n",
-                              priv->port, dev->dev_addr);
+                              priv->port, dev->ea);
                        err = -EINVAL;
                        goto out;
                }
        }
 
-       memcpy(priv->current_mac, dev->dev_addr, sizeof(priv->current_mac));
+       memcpy(priv->current_mac, dev->ea, sizeof(priv->current_mac));
 
-       priv->stride = roundup_pow_of_two(sizeof(struct mlx4_en_rx_desc) +
-                                         DS_SIZE * MLX4_EN_MAX_RX_FRAGS);
+       priv->stride = ROUNDUPPWR2(sizeof(struct mlx4_en_rx_desc) + DS_SIZE * MLX4_EN_MAX_RX_FRAGS);
        err = mlx4_en_alloc_resources(priv);
        if (err)
                goto out;
@@ -2894,15 +2899,12 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
         * Initialize netdev entry points
         */
        if (mlx4_is_master(priv->mdev->dev))
-               dev->netdev_ops = &mlx4_netdev_ops_master;
-       else
-               dev->netdev_ops = &mlx4_netdev_ops;
-       dev->watchdog_timeo = MLX4_EN_WATCHDOG_TIMEOUT;
+               {}
+               else
+                       {}
        netif_set_real_num_tx_queues(dev, priv->tx_ring_num);
        netif_set_real_num_rx_queues(dev, priv->rx_ring_num);
 
-       dev->ethtool_ops = &mlx4_en_ethtool_ops;
-
        /*
         * Set driver features
         */
@@ -2910,10 +2912,8 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        if (mdev->LSO_support)
                dev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6;
 
-       dev->vlan_features = dev->hw_features;
-
        dev->hw_features |= NETIF_F_RXCSUM | NETIF_F_RXHASH;
-       dev->features = dev->hw_features | NETIF_F_HIGHDMA |
+       dev->feat = dev->hw_features | NETIF_F_HIGHDMA |
                        NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX |
                        NETIF_F_HW_VLAN_CTAG_FILTER;
        dev->hw_features |= NETIF_F_LOOPBACK |
@@ -2953,7 +2953,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        en_warn(priv, "Using %d TX rings\n", prof->tx_ring_num);
        en_warn(priv, "Using %d RX rings\n", prof->rx_ring_num);
 
-       mlx4_en_update_loopback_state(priv->dev, priv->dev->features);
+       mlx4_en_update_loopback_state(priv->dev, priv->dev->feat);
 
        /* Configure port */
        mlx4_en_calc_rx_buf(dev);
@@ -3010,7 +3010,7 @@ out:
        return err;
 }
 
-int mlx4_en_reset_config(struct net_device *dev,
+int mlx4_en_reset_config(struct ether *dev,
                         struct hwtstamp_config ts_config,
                         netdev_features_t features)
 {
@@ -3032,7 +3032,7 @@ int mlx4_en_reset_config(struct net_device *dev,
                return -EINVAL;
        }
 
-       mutex_lock(&mdev->state_lock);
+       qlock(&mdev->state_lock);
        if (priv->port_up) {
                port_up = 1;
                mlx4_en_stop_port(dev, 1);
@@ -3048,24 +3048,24 @@ int mlx4_en_reset_config(struct net_device *dev,
 
        if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_HW_VLAN_CTAG_RX)) {
                if (features & NETIF_F_HW_VLAN_CTAG_RX)
-                       dev->features |= NETIF_F_HW_VLAN_CTAG_RX;
+                       dev->feat |= NETIF_F_HW_VLAN_CTAG_RX;
                else
-                       dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
+                       dev->feat &= ~NETIF_F_HW_VLAN_CTAG_RX;
        } else if (ts_config.rx_filter == HWTSTAMP_FILTER_NONE) {
                /* RX time-stamping is OFF, update the RX vlan offload
                 * to the latest wanted state
                 */
                if (dev->wanted_features & NETIF_F_HW_VLAN_CTAG_RX)
-                       dev->features |= NETIF_F_HW_VLAN_CTAG_RX;
+                       dev->feat |= NETIF_F_HW_VLAN_CTAG_RX;
                else
-                       dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
+                       dev->feat &= ~NETIF_F_HW_VLAN_CTAG_RX;
        }
 
        if (DEV_FEATURE_CHANGED(dev, features, NETIF_F_RXFCS)) {
                if (features & NETIF_F_RXFCS)
-                       dev->features |= NETIF_F_RXFCS;
+                       dev->feat |= NETIF_F_RXFCS;
                else
-                       dev->features &= ~NETIF_F_RXFCS;
+                       dev->feat &= ~NETIF_F_RXFCS;
        }
 
        /* RX vlan offload and RX time-stamping can't co-exist !
@@ -3073,9 +3073,9 @@ int mlx4_en_reset_config(struct net_device *dev,
         * Turn Off RX vlan offload in case of time-stamping is ON
         */
        if (ts_config.rx_filter != HWTSTAMP_FILTER_NONE) {
-               if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)
+               if (dev->feat & NETIF_F_HW_VLAN_CTAG_RX)
                        en_warn(priv, "Turning off RX vlan offload since RX time-stamping is ON\n");
-               dev->features &= ~NETIF_F_HW_VLAN_CTAG_RX;
+               dev->feat &= ~NETIF_F_HW_VLAN_CTAG_RX;
        }
 
        err = mlx4_en_alloc_resources(priv);
@@ -3090,7 +3090,7 @@ int mlx4_en_reset_config(struct net_device *dev,
        }
 
 out:
-       mutex_unlock(&mdev->state_lock);
+       qunlock(&mdev->state_lock);
        netdev_features_change(dev);
        return err;
 }
index 0a56f01..3a04714 100644 (file)
@@ -48,7 +48,7 @@ int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, struct mlx4_en_priv *priv)
        int i;
        int j;
        int index = 0;
-       u32 entry;
+       uint32_t entry;
        int err = 0;
 
        mailbox = mlx4_alloc_cmd_mailbox(dev);
@@ -69,7 +69,7 @@ int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, struct mlx4_en_priv *priv)
        return err;
 }
 
-int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, u8 port)
+int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, uint8_t port)
 {
        struct mlx4_en_query_port_context *qport_context;
        struct mlx4_en_priv *priv = netdev_priv(mdev->pndev[port]);
@@ -147,14 +147,15 @@ static unsigned long en_stats_adder(__be64 *start, __be64 *next, int num)
        return ret;
 }
 
-int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
+int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, uint8_t port,
+                          uint8_t reset)
 {
        struct mlx4_en_stat_out_mbox *mlx4_en_stats;
        struct mlx4_en_stat_out_flow_control_mbox *flowstats;
        struct mlx4_en_priv *priv = netdev_priv(mdev->pndev[port]);
        struct net_device_stats *stats = &priv->stats;
        struct mlx4_cmd_mailbox *mailbox;
-       u64 in_mod = reset << 8 | port;
+       uint64_t in_mod = reset << 8 | port;
        int err;
        int i;
 
@@ -169,7 +170,7 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
 
        mlx4_en_stats = mailbox->buf;
 
-       spin_lock_bh(&priv->stats_lock);
+       spin_lock(&priv->stats_lock);
 
        stats->rx_packets = 0;
        stats->rx_bytes = 0;
@@ -294,7 +295,7 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
        priv->pkstats.tx_prio[8][0] = be64_to_cpu(mlx4_en_stats->TTOT_novlan);
        priv->pkstats.tx_prio[8][1] = be64_to_cpu(mlx4_en_stats->TOCT_novlan);
 
-       spin_unlock_bh(&priv->stats_lock);
+       spin_unlock(&priv->stats_lock);
 
        /* 0xffs indicates invalid value */
        memset(mailbox->buf, 0xff, sizeof(*flowstats) * MLX4_NUM_PRIORITIES);
@@ -312,7 +313,7 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
 
        flowstats = mailbox->buf;
 
-       spin_lock_bh(&priv->stats_lock);
+       spin_lock(&priv->stats_lock);
 
        for (i = 0; i < MLX4_NUM_PRIORITIES; i++)       {
                priv->rx_priority_flowstats[i].rx_pause =
@@ -343,7 +344,7 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
        priv->tx_flowstats.tx_pause_transition =
                be64_to_cpu(flowstats[0].tx_pause_transition);
 
-       spin_unlock_bh(&priv->stats_lock);
+       spin_unlock(&priv->stats_lock);
 
 out:
        mlx4_free_cmd_mailbox(mdev->dev, mailbox);
index 040da4b..6abae40 100644 (file)
@@ -87,18 +87,18 @@ enum {
 };
 
 struct mlx4_en_query_port_context {
-       u8 link_up;
+       uint8_t link_up;
 #define MLX4_EN_LINK_UP_MASK   0x80
 #define MLX4_EN_ANC_MASK       0x40
-       u8 autoneg;
+       uint8_t autoneg;
 #define MLX4_EN_AUTONEG_MASK   0x80
        __be16 mtu;
-       u8 reserved2;
-       u8 link_speed;
+       uint8_t reserved2;
+       uint8_t link_speed;
 #define MLX4_EN_SPEED_MASK     0x6f
-       u16 reserved3[5];
+       uint16_t reserved3[5];
        __be64 mac;
-       u8 transceiver;
+       uint8_t transceiver;
 };
 
 
index 34f2fdf..4c94112 100644 (file)
@@ -42,21 +42,21 @@ void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride,
                             int user_prio, struct mlx4_qp_context *context)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
-       struct net_device *dev = priv->dev;
+       struct ether *dev = priv->dev;
 
        memset(context, 0, sizeof *context);
        context->flags = cpu_to_be32(7 << 16 | rss << MLX4_RSS_QPC_FLAG_OFFSET);
        context->pd = cpu_to_be32(mdev->priv_pdn);
        context->mtu_msgmax = 0xff;
        if (!is_tx && !rss)
-               context->rq_size_stride = ilog2(size) << 3 | (ilog2(stride) - 4);
+               context->rq_size_stride = LOG2_UP(size) << 3 | (LOG2_UP(stride) - 4);
        if (is_tx) {
-               context->sq_size_stride = ilog2(size) << 3 | (ilog2(stride) - 4);
+               context->sq_size_stride = LOG2_UP(size) << 3 | (LOG2_UP(stride) - 4);
                if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_PORT_REMAP)
                        context->params2 |= MLX4_QP_BIT_FPP;
 
        } else {
-               context->sq_size_stride = ilog2(TXBB_SIZE) - 4;
+               context->sq_size_stride = LOG2_UP(TXBB_SIZE) - 4;
        }
        context->usr_page = cpu_to_be32(mdev->priv_uar.index);
        context->local_qpn = cpu_to_be32(qpn);
@@ -70,7 +70,7 @@ void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride,
        context->cqn_send = cpu_to_be32(cqn);
        context->cqn_recv = cpu_to_be32(cqn);
        context->db_rec_addr = cpu_to_be64(priv->res.db.dma << 2);
-       if (!(dev->features & NETIF_F_HW_VLAN_CTAG_RX))
+       if (!(dev->feat & NETIF_F_HW_VLAN_CTAG_RX))
                context->param3 |= cpu_to_be32(1 << 30);
 
        if (!is_tx && !rss &&
@@ -89,12 +89,12 @@ int mlx4_en_map_buffer(struct mlx4_buf *buf)
        if (BITS_PER_LONG == 64 || buf->nbufs == 1)
                return 0;
 
-       pages = kmalloc(sizeof *pages * buf->nbufs, GFP_KERNEL);
+       pages = kmalloc(sizeof *pages * buf->nbufs, KMALLOC_WAIT);
        if (!pages)
                return -ENOMEM;
 
        for (i = 0; i < buf->nbufs; ++i)
-               pages[i] = virt_to_page(buf->page_list[i].buf);
+               pages[i] = kva2page(buf->page_list[i].buf);
 
        buf->direct.buf = vmap(pages, buf->nbufs, VM_MAP, PAGE_KERNEL);
        kfree(pages);
index 2a77a6b..8f1316e 100644 (file)
@@ -62,7 +62,7 @@ static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
 
                if (order)
                        gfp |= __GFP_COMP | __GFP_NOWARN;
-               page = alloc_pages(gfp, order);
+               page = kva2page(get_cont_pages(order, gfp));
                if (likely(page))
                        break;
                if (--order < 0 ||
@@ -72,7 +72,7 @@ static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
        dma = dma_map_page(priv->ddev, page, 0, PAGE_SIZE << order,
                           PCI_DMA_FROMDEVICE);
        if (dma_mapping_error(priv->ddev, dma)) {
-               put_page(page);
+               page_decref(page);
                return -ENOMEM;
        }
        page_alloc->page_size = PAGE_SIZE << order;
@@ -83,7 +83,7 @@ static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
         * on asymetric workloads. Note we can not use atomic_set().
         */
        atomic_add(page_alloc->page_size / frag_info->frag_stride - 1,
-                  &page->_count);
+                  &page->pg_kref.refcount);
        return 0;
 }
 
@@ -127,8 +127,8 @@ out:
                        dma_unmap_page(priv->ddev, page_alloc[i].dma,
                                page_alloc[i].page_size, PCI_DMA_FROMDEVICE);
                        page = page_alloc[i].page;
-                       atomic_set(&page->_count, 1);
-                       put_page(page);
+                       atomic_set(&page->pg_kref.refcount, 1);
+                       page_decref(page);
                }
        }
        return -ENOMEM;
@@ -139,7 +139,7 @@ static void mlx4_en_free_frag(struct mlx4_en_priv *priv,
                              int i)
 {
        const struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
-       u32 next_frag_end = frags[i].page_offset + 2 * frag_info->frag_stride;
+       uint32_t next_frag_end = frags[i].page_offset + 2 * frag_info->frag_stride;
 
 
        if (next_frag_end > frags[i].page_size)
@@ -147,7 +147,7 @@ static void mlx4_en_free_frag(struct mlx4_en_priv *priv,
                               PCI_DMA_FROMDEVICE);
 
        if (frags[i].page)
-               put_page(frags[i].page);
+               page_decref(frags[i].page);
 }
 
 static int mlx4_en_init_allocator(struct mlx4_en_priv *priv,
@@ -160,12 +160,12 @@ static int mlx4_en_init_allocator(struct mlx4_en_priv *priv,
                const struct mlx4_en_frag_info *frag_info = &priv->frag_info[i];
 
                if (mlx4_alloc_pages(priv, &ring->page_alloc[i],
-                                    frag_info, GFP_KERNEL | __GFP_COLD))
+                                    frag_info, KMALLOC_WAIT | __GFP_COLD))
                        goto out;
 
                en_dbg(DRV, priv, "  frag %d allocator: - size:%d frags:%d\n",
                       i, ring->page_alloc[i].page_size,
-                      atomic_read(&ring->page_alloc[i].page->_count));
+                      atomic_read(&ring->page_alloc[i].page->pg_kref.refcount));
        }
        return 0;
 
@@ -177,8 +177,8 @@ out:
                dma_unmap_page(priv->ddev, page_alloc->dma,
                               page_alloc->page_size, PCI_DMA_FROMDEVICE);
                page = page_alloc->page;
-               atomic_set(&page->_count, 1);
-               put_page(page);
+               atomic_set(&page->pg_kref.refcount, 1);
+               page_decref(page);
                page_alloc->page = NULL;
        }
        return -ENOMEM;
@@ -201,7 +201,7 @@ static void mlx4_en_destroy_allocator(struct mlx4_en_priv *priv,
                                page_alloc->page_size, PCI_DMA_FROMDEVICE);
                while (page_alloc->page_offset + frag_info->frag_stride <
                       page_alloc->page_size) {
-                       put_page(page_alloc->page);
+                       page_decref(page_alloc->page);
                        page_alloc->page_offset += frag_info->frag_stride;
                }
                page_alloc->page = NULL;
@@ -246,7 +246,7 @@ static int mlx4_en_prepare_rx_desc(struct mlx4_en_priv *priv,
 
 static inline bool mlx4_en_is_ring_empty(struct mlx4_en_rx_ring *ring)
 {
-       BUG_ON((u32)(ring->prod - ring->cons) > ring->actual_size);
+       assert(!((uint32_t)(ring->prod - ring->cons) > ring->actual_size));
        return ring->prod == ring->cons;
 }
 
@@ -282,12 +282,12 @@ static int mlx4_en_fill_rx_buffers(struct mlx4_en_priv *priv)
 
                        if (mlx4_en_prepare_rx_desc(priv, ring,
                                                    ring->actual_size,
-                                                   GFP_KERNEL | __GFP_COLD)) {
+                                                   KMALLOC_WAIT | __GFP_COLD)) {
                                if (ring->actual_size < MLX4_EN_MIN_RX_SIZE) {
                                        en_err(priv, "Failed to allocate enough rx buffers\n");
                                        return -ENOMEM;
                                } else {
-                                       new_size = rounddown_pow_of_two(ring->actual_size);
+                                       new_size = ROUNDDOWNPWR2(ring->actual_size);
                                        en_warn(priv, "Only %d buffers allocated reducing ring size to %d\n",
                                                ring->actual_size, new_size);
                                        goto reduce_rings;
@@ -338,35 +338,32 @@ void mlx4_en_set_num_rx_rings(struct mlx4_en_dev *mdev)
 
        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {
                if (!dev->caps.comp_pool)
-                       num_of_eqs = max_t(int, MIN_RX_RINGS,
-                                          min_t(int,
-                                                dev->caps.num_comp_vectors,
-                                                DEF_RX_RINGS));
+                       num_of_eqs = MAX_T(int, MIN_RX_RINGS,
+                                          MIN_T(int, dev->caps.num_comp_vectors, DEF_RX_RINGS));
                else
-                       num_of_eqs = min_t(int, MAX_MSIX_P_PORT,
-                                          dev->caps.comp_pool/
-                                          dev->caps.num_ports) - 1;
+                       num_of_eqs = MIN_T(int, MAX_MSIX_P_PORT,
+                                          dev->caps.comp_pool / dev->caps.num_ports) - 1;
 
                num_rx_rings = mlx4_low_memory_profile() ? MIN_RX_RINGS :
-                       min_t(int, num_of_eqs,
+                       MIN_T(int, num_of_eqs,
                              netif_get_num_default_rss_queues());
                mdev->profile.prof[i].rx_ring_num =
-                       rounddown_pow_of_two(num_rx_rings);
+                       ROUNDDOWNPWR2(num_rx_rings);
        }
 }
 
 int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
                           struct mlx4_en_rx_ring **pring,
-                          u32 size, u16 stride, int node)
+                          uint32_t size, uint16_t stride, int node)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_rx_ring *ring;
        int err = -ENOMEM;
        int tmp;
 
-       ring = kzalloc_node(sizeof(*ring), GFP_KERNEL, node);
+       ring = kzalloc_node(sizeof(*ring), KMALLOC_WAIT, node);
        if (!ring) {
-               ring = kzalloc(sizeof(*ring), GFP_KERNEL);
+               ring = kzmalloc(sizeof(*ring), KMALLOC_WAIT);
                if (!ring) {
                        en_err(priv, "Failed to allocate RX ring structure\n");
                        return -ENOMEM;
@@ -381,8 +378,7 @@ int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
        ring->log_stride = ffs(ring->stride) - 1;
        ring->buf_size = ring->size * ring->stride + TXBB_SIZE;
 
-       tmp = size * roundup_pow_of_two(MLX4_EN_MAX_RX_FRAGS *
-                                       sizeof(struct mlx4_en_rx_alloc));
+       tmp = size * ROUNDUPPWR2(MLX4_EN_MAX_RX_FRAGS * sizeof(struct mlx4_en_rx_alloc));
        ring->rx_info = vmalloc_node(tmp, node);
        if (!ring->rx_info) {
                ring->rx_info = vmalloc(tmp);
@@ -433,8 +429,7 @@ int mlx4_en_activate_rx_rings(struct mlx4_en_priv *priv)
        int i;
        int ring_ind;
        int err;
-       int stride = roundup_pow_of_two(sizeof(struct mlx4_en_rx_desc) +
-                                       DS_SIZE * priv->num_frags);
+       int stride = ROUNDUPPWR2(sizeof(struct mlx4_en_rx_desc) + DS_SIZE * priv->num_frags);
 
        for (ring_ind = 0; ring_ind < priv->rx_ring_num; ring_ind++) {
                ring = priv->rx_ring[ring_ind];
@@ -515,7 +510,7 @@ void mlx4_en_recover_from_oom(struct mlx4_en_priv *priv)
 
 void mlx4_en_destroy_rx_ring(struct mlx4_en_priv *priv,
                             struct mlx4_en_rx_ring **pring,
-                            u32 size, u16 stride)
+                            uint32_t size, uint16_t stride)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_rx_ring *ring = *pring;
@@ -646,7 +641,7 @@ static struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv,
 static void validate_loopback(struct mlx4_en_priv *priv, struct sk_buff *skb)
 {
        int i;
-       int offset = ETH_HLEN;
+       int offset = ETHERHDRSIZE;
 
        for (i = 0; i < MLX4_LOOPBACK_TEST_PAYLOAD; i++, offset++) {
                if (*(skb->data + offset) != (unsigned char) (i & 0xff))
@@ -664,9 +659,9 @@ static void mlx4_en_refill_rx_buffers(struct mlx4_en_priv *priv,
 {
        int index = ring->prod & ring->size_mask;
 
-       while ((u32) (ring->prod - ring->cons) < ring->actual_size) {
+       while ((uint32_t) (ring->prod - ring->cons) < ring->actual_size) {
                if (mlx4_en_prepare_rx_desc(priv, ring, index,
-                                           GFP_ATOMIC | __GFP_COLD))
+                                           0 | __GFP_COLD))
                        break;
                ring->prod++;
                index = ring->prod & ring->size_mask;
@@ -676,21 +671,21 @@ static void mlx4_en_refill_rx_buffers(struct mlx4_en_priv *priv,
 /* When hardware doesn't strip the vlan, we need to calculate the checksum
  * over it and add it to the hardware's checksum calculation
  */
-static inline __wsum get_fixed_vlan_csum(__wsum hw_checksum,
-                                        struct vlan_hdr *vlanh)
+static inline uint32_t get_fixed_vlan_csum(uint32_t hw_checksum,
+                                          struct vlan_hdr *vlanh)
 {
-       return csum_add(hw_checksum, *(__wsum *)vlanh);
+       return csum_add(hw_checksum, *(uint32_t *)vlanh);
 }
 
 /* Although the stack expects checksum which doesn't include the pseudo
  * header, the HW adds it. To address that, we are subtracting the pseudo
  * header checksum from the checksum value provided by the HW.
  */
-static void get_fixed_ipv4_csum(__wsum hw_checksum, struct sk_buff *skb,
+static void get_fixed_ipv4_csum(uint32_t hw_checksum, struct sk_buff *skb,
                                struct iphdr *iph)
 {
-       __u16 length_for_csum = 0;
-       __wsum csum_pseudo_header = 0;
+       uint16_t length_for_csum = 0;
+       uint32_t csum_pseudo_header = 0;
 
        length_for_csum = (be16_to_cpu(iph->tot_len) - (iph->ihl << 2));
        csum_pseudo_header = csum_tcpudp_nofold(iph->saddr, iph->daddr,
@@ -703,19 +698,22 @@ static void get_fixed_ipv4_csum(__wsum hw_checksum, struct sk_buff *skb,
  * we also compute/add the IP header checksum which
  * is not added by the HW.
  */
-static int get_fixed_ipv6_csum(__wsum hw_checksum, struct sk_buff *skb,
+static int get_fixed_ipv6_csum(uint32_t hw_checksum, struct sk_buff *skb,
                               struct ipv6hdr *ipv6h)
 {
-       __wsum csum_pseudo_hdr = 0;
+       uint32_t csum_pseudo_hdr = 0;
 
        if (ipv6h->nexthdr == IPPROTO_FRAGMENT || ipv6h->nexthdr == IPPROTO_HOPOPTS)
                return -1;
-       hw_checksum = csum_add(hw_checksum, (__force __wsum)(ipv6h->nexthdr << 8));
+       hw_checksum = csum_add(hw_checksum,
+                              (__force uint32_t)(ipv6h->nexthdr << 8));
 
        csum_pseudo_hdr = csum_partial(&ipv6h->saddr,
                                       sizeof(ipv6h->saddr) + sizeof(ipv6h->daddr), 0);
-       csum_pseudo_hdr = csum_add(csum_pseudo_hdr, (__force __wsum)ipv6h->payload_len);
-       csum_pseudo_hdr = csum_add(csum_pseudo_hdr, (__force __wsum)ntohs(ipv6h->nexthdr));
+       csum_pseudo_hdr = csum_add(csum_pseudo_hdr,
+                                  (__force uint32_t)ipv6h->payload_len);
+       csum_pseudo_hdr = csum_add(csum_pseudo_hdr,
+                                  (__force uint32_t)be16_to_cpu(ipv6h->nexthdr));
 
        skb->csum = csum_sub(hw_checksum, csum_pseudo_hdr);
        skb->csum = csum_add(skb->csum, csum_partial(ipv6h, sizeof(struct ipv6hdr), 0));
@@ -725,19 +723,19 @@ static int get_fixed_ipv6_csum(__wsum hw_checksum, struct sk_buff *skb,
 static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va,
                      int hwtstamp_rx_filter)
 {
-       __wsum hw_checksum = 0;
+       uint32_t hw_checksum = 0;
 
-       void *hdr = (u8 *)va + sizeof(struct ethhdr);
+       void *hdr = (uint8_t *)va + sizeof(struct ethhdr);
 
-       hw_checksum = csum_unfold((__force __sum16)cqe->checksum);
+       hw_checksum = csum_unfold((__force uint16_t)cqe->checksum);
 
-       if (((struct ethhdr *)va)->h_proto == htons(ETH_P_8021Q) &&
+       if (((struct ethhdr *)va)->h_proto == cpu_to_be16(ETH_P_8021Q) &&
            hwtstamp_rx_filter != HWTSTAMP_FILTER_NONE) {
                /* next protocol non IPv4 or IPv6 */
                if (((struct vlan_hdr *)hdr)->h_vlan_encapsulated_proto
-                   != htons(ETH_P_IP) &&
+                   != cpu_to_be16(ETH_P_IP) &&
                    ((struct vlan_hdr *)hdr)->h_vlan_encapsulated_proto
-                   != htons(ETH_P_IPV6))
+                   != cpu_to_be16(ETH_P_IPV6))
                        return -1;
                hw_checksum = get_fixed_vlan_csum(hw_checksum, hdr);
                hdr += sizeof(struct vlan_hdr);
@@ -753,7 +751,8 @@ static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va,
        return 0;
 }
 
-int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int budget)
+int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
+                         int budget)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
@@ -768,7 +767,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
        int polled = 0;
        int ip_summed;
        int factor = priv->cqe_factor;
-       u64 timestamp;
+       uint64_t timestamp;
        bool l2_tunnel;
 
        if (!priv->port_up)
@@ -793,7 +792,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                /*
                 * make sure we read the CQE after we read the ownership bit
                 */
-               dma_rmb();
+               bus_rmb();
 
                /* Drop packet on bad receive or bad checksum */
                if (unlikely((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) ==
@@ -853,7 +852,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                l2_tunnel = (dev->hw_enc_features & NETIF_F_RXCSUM) &&
                        (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_L2_TUNNEL));
 
-               if (likely(dev->features & NETIF_F_RXCSUM)) {
+               if (likely(dev->feat & NETIF_F_RXCSUM)) {
                        if (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_TCP |
                                                      MLX4_CQE_STATUS_UDP)) {
                                if ((cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPOK)) &&
@@ -888,7 +887,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                 * - no LLS polling in progress
                 */
                if (!mlx4_en_cq_busy_polling(cq) &&
-                   (dev->features & NETIF_F_GRO)) {
+                   (dev->feat & NETIF_F_GRO)) {
                        struct sk_buff *gro_skb = napi_get_frags(&cq->napi);
                        if (!gro_skb)
                                goto next;
@@ -918,13 +917,15 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
 
                        if ((cqe->vlan_my_qpn &
                            cpu_to_be32(MLX4_CQE_VLAN_PRESENT_MASK)) &&
-                           (dev->features & NETIF_F_HW_VLAN_CTAG_RX)) {
-                               u16 vid = be16_to_cpu(cqe->sl_vid);
+                           (dev->feat & NETIF_F_HW_VLAN_CTAG_RX)) {
+                               uint16_t vid = be16_to_cpu(cqe->sl_vid);
 
-                               __vlan_hwaccel_put_tag(gro_skb, htons(ETH_P_8021Q), vid);
+                               __vlan_hwaccel_put_tag(gro_skb,
+                                                      cpu_to_be16(ETH_P_8021Q),
+                                                      vid);
                        }
 
-                       if (dev->features & NETIF_F_RXHASH)
+                       if (dev->feat & NETIF_F_RXHASH)
                                skb_set_hash(gro_skb,
                                             be32_to_cpu(cqe->immed_rss_invalid),
                                             PKT_HASH_TYPE_L3);
@@ -970,15 +971,16 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                if (l2_tunnel && ip_summed == CHECKSUM_UNNECESSARY)
                        skb->csum_level = 1;
 
-               if (dev->features & NETIF_F_RXHASH)
+               if (dev->feat & NETIF_F_RXHASH)
                        skb_set_hash(skb,
                                     be32_to_cpu(cqe->immed_rss_invalid),
                                     PKT_HASH_TYPE_L3);
 
                if ((be32_to_cpu(cqe->vlan_my_qpn) &
                    MLX4_CQE_VLAN_PRESENT_MASK) &&
-                   (dev->features & NETIF_F_HW_VLAN_CTAG_RX))
-                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), be16_to_cpu(cqe->sl_vid));
+                   (dev->feat & NETIF_F_HW_VLAN_CTAG_RX))
+                       __vlan_hwaccel_put_tag(skb, cpu_to_be16(ETH_P_8021Q),
+                                              be16_to_cpu(cqe->sl_vid));
 
                if (ring->hwtstamp_rx_filter == HWTSTAMP_FILTER_ALL) {
                        timestamp = mlx4_en_get_cqe_ts(cqe);
@@ -1030,7 +1032,7 @@ void mlx4_en_rx_irq(struct mlx4_cq *mcq)
 int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget)
 {
        struct mlx4_en_cq *cq = container_of(napi, struct mlx4_en_cq, napi);
-       struct net_device *dev = cq->dev;
+       struct ether *dev = cq->dev;
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int done;
 
@@ -1048,7 +1050,7 @@ int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget)
 
                INC_PERF_COUNTER(priv->pstats.napi_quota);
 
-               cpu_curr = smp_processor_id();
+               cpu_curr = core_id();
                aff = irq_desc_get_irq_data(cq->irq_desc)->affinity;
 
                if (likely(cpumask_test_cpu(cpu_curr, aff)))
@@ -1073,10 +1075,10 @@ static const int frag_sizes[] = {
        FRAG_SZ3
 };
 
-void mlx4_en_calc_rx_buf(struct net_device *dev)
+void mlx4_en_calc_rx_buf(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
-       int eff_mtu = dev->mtu + ETH_HLEN + VLAN_HLEN;
+       int eff_mtu = dev->maxmtu + ETHERHDRSIZE + VLAN_HLEN;
        int buf_size = 0;
        int i = 0;
 
@@ -1119,11 +1121,11 @@ static int mlx4_en_config_rss_qp(struct mlx4_en_priv *priv, int qpn,
        struct mlx4_qp_context *context;
        int err = 0;
 
-       context = kmalloc(sizeof(*context), GFP_KERNEL);
+       context = kmalloc(sizeof(*context), KMALLOC_WAIT);
        if (!context)
                return -ENOMEM;
 
-       err = mlx4_qp_alloc(mdev->dev, qpn, qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(mdev->dev, qpn, qp, KMALLOC_WAIT);
        if (err) {
                en_err(priv, "Failed to allocate qp #%x\n", qpn);
                goto out;
@@ -1138,7 +1140,7 @@ static int mlx4_en_config_rss_qp(struct mlx4_en_priv *priv, int qpn,
        /* Cancel FCS removal if FW allows */
        if (mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_FCS_KEEP) {
                context->param3 |= cpu_to_be32(1 << 29);
-               if (priv->dev->features & NETIF_F_RXFCS)
+               if (priv->dev->feat & NETIF_F_RXFCS)
                        ring->fcs_del = 0;
                else
                        ring->fcs_del = ETH_FCS_LEN;
@@ -1159,7 +1161,7 @@ out:
 int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
 {
        int err;
-       u32 qpn;
+       uint32_t qpn;
 
        err = mlx4_qp_reserve_range(priv->mdev->dev, 1, 1, &qpn,
                                    MLX4_RESERVE_A0_QP);
@@ -1167,7 +1169,8 @@ int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
                en_err(priv, "Failed reserving drop qpn\n");
                return err;
        }
-       err = mlx4_qp_alloc(priv->mdev->dev, qpn, &priv->drop_qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(priv->mdev->dev, qpn, &priv->drop_qp,
+                           KMALLOC_WAIT);
        if (err) {
                en_err(priv, "Failed allocating drop qp\n");
                mlx4_qp_release_range(priv->mdev->dev, qpn, 1);
@@ -1179,7 +1182,7 @@ int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
 
 void mlx4_en_destroy_drop_qp(struct mlx4_en_priv *priv)
 {
-       u32 qpn;
+       uint32_t qpn;
 
        qpn = priv->drop_qp.qpn;
        mlx4_qp_remove(priv->mdev->dev, &priv->drop_qp);
@@ -1196,7 +1199,7 @@ int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv)
        struct mlx4_rss_context *rss_context;
        int rss_rings;
        void *ptr;
-       u8 rss_mask = (MLX4_RSS_IPV4 | MLX4_RSS_TCP_IPV4 | MLX4_RSS_IPV6 |
+       uint8_t rss_mask = (MLX4_RSS_IPV4 | MLX4_RSS_TCP_IPV4 | MLX4_RSS_IPV6 |
                        MLX4_RSS_TCP_IPV6);
        int i, qpn;
        int err = 0;
@@ -1223,7 +1226,8 @@ int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv)
        }
 
        /* Configure RSS indirection qp */
-       err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, &rss_map->indir_qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(mdev->dev, priv->base_qpn, &rss_map->indir_qp,
+                           KMALLOC_WAIT);
        if (err) {
                en_err(priv, "Failed to allocate RSS indirection QP\n");
                goto rss_err;
@@ -1240,7 +1244,7 @@ int mlx4_en_config_rss_steer(struct mlx4_en_priv *priv)
        ptr = ((void *) &context) + offsetof(struct mlx4_qp_context, pri_path)
                                        + MLX4_RSS_OFFSET_IN_QPC_PRI_PATH;
        rss_context = ptr;
-       rss_context->base_qpn = cpu_to_be32(ilog2(rss_rings) << 24 |
+       rss_context->base_qpn = cpu_to_be32(LOG2_UP(rss_rings) << 24 |
                                            (rss_map->base_qpn));
        rss_context->default_qpn = cpu_to_be32(rss_map->base_qpn);
        if (priv->mdev->profile.udp_rss) {
index b66e03d..79824b5 100644 (file)
@@ -57,7 +57,8 @@ static int mlx4_en_test_loopback_xmit(struct mlx4_en_priv *priv)
 
 
        /* build the pkt before xmit */
-       skb = netdev_alloc_skb(priv->dev, MLX4_LOOPBACK_TEST_PAYLOAD + ETH_HLEN + NET_IP_ALIGN);
+       skb = netdev_alloc_skb(priv->dev,
+                              MLX4_LOOPBACK_TEST_PAYLOAD + ETHERHDRSIZE + NET_IP_ALIGN);
        if (!skb)
                return -ENOMEM;
 
@@ -65,9 +66,9 @@ static int mlx4_en_test_loopback_xmit(struct mlx4_en_priv *priv)
 
        ethh = (struct ethhdr *)skb_put(skb, sizeof(struct ethhdr));
        packet  = (unsigned char *)skb_put(skb, packet_size);
-       memcpy(ethh->h_dest, priv->dev->dev_addr, ETH_ALEN);
+       memcpy(ethh->h_dest, priv->dev->ea, Eaddrlen);
        eth_zero_addr(ethh->h_source);
-       ethh->h_proto = htons(ETH_P_ARP);
+       ethh->h_proto = cpu_to_be16(ETH_P_ARP);
        skb_set_mac_header(skb, 0);
        for (i = 0; i < packet_size; ++i)       /* fill our packet */
                packet[i] = (unsigned char)(i & 0xff);
@@ -79,16 +80,16 @@ static int mlx4_en_test_loopback_xmit(struct mlx4_en_priv *priv)
 
 static int mlx4_en_test_loopback(struct mlx4_en_priv *priv)
 {
-       u32 loopback_ok = 0;
+       uint32_t loopback_ok = 0;
        int i;
        bool gro_enabled;
 
         priv->loopback_ok = 0;
        priv->validate_loopback = 1;
-       gro_enabled = priv->dev->features & NETIF_F_GRO;
+       gro_enabled = priv->dev->feat & NETIF_F_GRO;
 
-       mlx4_en_update_loopback_state(priv->dev, priv->dev->features);
-       priv->dev->features &= ~NETIF_F_GRO;
+       mlx4_en_update_loopback_state(priv->dev, priv->dev->feat);
+       priv->dev->feat &= ~NETIF_F_GRO;
 
        /* xmit */
        if (mlx4_en_test_loopback_xmit(priv)) {
@@ -98,7 +99,7 @@ static int mlx4_en_test_loopback(struct mlx4_en_priv *priv)
 
        /* polling for result */
        for (i = 0; i < MLX4_EN_LOOPBACK_RETRIES; ++i) {
-               msleep(MLX4_EN_LOOPBACK_TIMEOUT);
+               kthread_usleep(1000 * MLX4_EN_LOOPBACK_TIMEOUT);
                if (priv->loopback_ok) {
                        loopback_ok = 1;
                        break;
@@ -112,9 +113,9 @@ mlx4_en_test_loopback_exit:
        priv->validate_loopback = 0;
 
        if (gro_enabled)
-               priv->dev->features |= NETIF_F_GRO;
+               priv->dev->feat |= NETIF_F_GRO;
 
-       mlx4_en_update_loopback_state(priv->dev, priv->dev->features);
+       mlx4_en_update_loopback_state(priv->dev, priv->dev->feat);
        return !loopback_ok;
 }
 
@@ -148,13 +149,14 @@ static int mlx4_en_test_speed(struct mlx4_en_priv *priv)
 }
 
 
-void mlx4_en_ex_selftest(struct net_device *dev, u32 *flags, u64 *buf)
+void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
+                        uint64_t *buf)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        int i, carrier_ok;
 
-       memset(buf, 0, sizeof(u64) * MLX4_EN_NUM_SELF_TEST);
+       memset(buf, 0, sizeof(uint64_t) * MLX4_EN_NUM_SELF_TEST);
 
        if (*flags & ETH_TEST_FL_OFFLINE) {
                /* disable the interface */
@@ -164,7 +166,7 @@ void mlx4_en_ex_selftest(struct net_device *dev, u32 *flags, u64 *buf)
                /* Wait until all tx queues are empty.
                 * there should not be any additional incoming traffic
                 * since we turned the carrier off */
-               msleep(200);
+               kthread_usleep(1000 * 200);
 
                if (priv->mdev->dev->caps.flags &
                                        MLX4_DEV_CAP_FLAG_UC_LOOPBACK) {
index 7bed3a8..7d476e0 100644 (file)
 #include "mlx4_en.h"
 
 int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
-                          struct mlx4_en_tx_ring **pring, u32 size,
-                          u16 stride, int node, int queue_index)
+                          struct mlx4_en_tx_ring **pring, uint32_t size,
+                          uint16_t stride, int node, int queue_index)
 {
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_tx_ring *ring;
        int tmp;
        int err;
 
-       ring = kzalloc_node(sizeof(*ring), GFP_KERNEL, node);
+       ring = kzalloc_node(sizeof(*ring), KMALLOC_WAIT, node);
        if (!ring) {
-               ring = kzalloc(sizeof(*ring), GFP_KERNEL);
+               ring = kzmalloc(sizeof(*ring), KMALLOC_WAIT);
                if (!ring) {
                        en_err(priv, "Failed allocating TX ring\n");
                        return -ENOMEM;
@@ -68,7 +68,7 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
        ring->stride = stride;
 
        tmp = size * sizeof(struct mlx4_en_tx_info);
-       ring->tx_info = kmalloc_node(tmp, GFP_KERNEL | __GFP_NOWARN, node);
+       ring->tx_info = kmalloc_node(tmp, KMALLOC_WAIT | __GFP_NOWARN, node);
        if (!ring->tx_info) {
                ring->tx_info = vmalloc(tmp);
                if (!ring->tx_info) {
@@ -80,9 +80,9 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
        en_dbg(DRV, priv, "Allocated tx_info ring at addr:%p size:%d\n",
                 ring->tx_info, tmp);
 
-       ring->bounce_buf = kmalloc_node(MAX_DESC_SIZE, GFP_KERNEL, node);
+       ring->bounce_buf = kmalloc_node(MAX_DESC_SIZE, KMALLOC_WAIT, node);
        if (!ring->bounce_buf) {
-               ring->bounce_buf = kmalloc(MAX_DESC_SIZE, GFP_KERNEL);
+               ring->bounce_buf = kmalloc(MAX_DESC_SIZE, KMALLOC_WAIT);
                if (!ring->bounce_buf) {
                        err = -ENOMEM;
                        goto err_info;
@@ -119,7 +119,7 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
                goto err_map;
        }
 
-       err = mlx4_qp_alloc(mdev->dev, ring->qpn, &ring->qp, GFP_KERNEL);
+       err = mlx4_qp_alloc(mdev->dev, ring->qpn, &ring->qp, KMALLOC_WAIT);
        if (err) {
                en_err(priv, "Failed allocating qp %d\n", ring->qpn);
                goto err_reserve;
@@ -233,7 +233,7 @@ void mlx4_en_deactivate_tx_ring(struct mlx4_en_priv *priv,
 
 static void mlx4_en_stamp_wqe(struct mlx4_en_priv *priv,
                              struct mlx4_en_tx_ring *ring, int index,
-                             u8 owner)
+                             uint8_t owner)
 {
        __be32 stamp = cpu_to_be32(STAMP_VAL | (!!owner << STAMP_SHIFT));
        struct mlx4_en_tx_desc *tx_desc = ring->buf + index * TXBB_SIZE;
@@ -265,9 +265,9 @@ static void mlx4_en_stamp_wqe(struct mlx4_en_priv *priv,
 }
 
 
-static u32 mlx4_en_free_tx_desc(struct mlx4_en_priv *priv,
+static uint32_t mlx4_en_free_tx_desc(struct mlx4_en_priv *priv,
                                struct mlx4_en_tx_ring *ring,
-                               int index, u8 owner, u64 timestamp)
+                               int index, uint8_t owner, uint64_t timestamp)
 {
        struct mlx4_en_tx_info *tx_info = &ring->tx_info[index];
        struct mlx4_en_tx_desc *tx_desc = ring->buf + index * TXBB_SIZE;
@@ -343,7 +343,7 @@ static u32 mlx4_en_free_tx_desc(struct mlx4_en_priv *priv,
 }
 
 
-int mlx4_en_free_tx_buf(struct net_device *dev, struct mlx4_en_tx_ring *ring)
+int mlx4_en_free_tx_buf(struct ether *dev, struct mlx4_en_tx_ring *ring)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int cnt = 0;
@@ -353,7 +353,7 @@ int mlx4_en_free_tx_buf(struct net_device *dev, struct mlx4_en_tx_ring *ring)
        en_dbg(DRV, priv, "Freeing Tx buf - cons:0x%x prod:0x%x\n",
                 ring->cons, ring->prod);
 
-       if ((u32) (ring->prod - ring->cons) > ring->size) {
+       if ((uint32_t) (ring->prod - ring->cons) > ring->size) {
                if (netif_msg_tx_err(priv))
                        en_warn(priv, "Tx consumer passed producer!\n");
                return 0;
@@ -375,29 +375,29 @@ int mlx4_en_free_tx_buf(struct net_device *dev, struct mlx4_en_tx_ring *ring)
        return cnt;
 }
 
-static bool mlx4_en_process_tx_cq(struct net_device *dev,
-                                struct mlx4_en_cq *cq)
+static bool mlx4_en_process_tx_cq(struct ether *dev,
+                                 struct mlx4_en_cq *cq)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_cq *mcq = &cq->mcq;
        struct mlx4_en_tx_ring *ring = priv->tx_ring[cq->ring];
        struct mlx4_cqe *cqe;
-       u16 index;
-       u16 new_index, ring_index, stamp_index;
-       u32 txbbs_skipped = 0;
-       u32 txbbs_stamp = 0;
-       u32 cons_index = mcq->cons_index;
+       uint16_t index;
+       uint16_t new_index, ring_index, stamp_index;
+       uint32_t txbbs_skipped = 0;
+       uint32_t txbbs_stamp = 0;
+       uint32_t cons_index = mcq->cons_index;
        int size = cq->size;
-       u32 size_mask = ring->size_mask;
+       uint32_t size_mask = ring->size_mask;
        struct mlx4_cqe *buf = cq->buf;
-       u32 packets = 0;
-       u32 bytes = 0;
+       uint32_t packets = 0;
+       uint32_t bytes = 0;
        int factor = priv->cqe_factor;
-       u64 timestamp = 0;
+       uint64_t timestamp = 0;
        int done = 0;
        int budget = priv->tx_work_limit;
-       u32 last_nr_txbb;
-       u32 ring_cons;
+       uint32_t last_nr_txbb;
+       uint32_t ring_cons;
 
        if (!priv->port_up)
                return true;
@@ -418,7 +418,7 @@ static bool mlx4_en_process_tx_cq(struct net_device *dev,
                 * make sure we read the CQE after we read the
                 * ownership bit
                 */
-               dma_rmb();
+               bus_rmb();
 
                if (unlikely((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) ==
                             MLX4_CQE_OPCODE_ERROR)) {
@@ -499,7 +499,7 @@ void mlx4_en_tx_irq(struct mlx4_cq *mcq)
 int mlx4_en_poll_tx_cq(struct napi_struct *napi, int budget)
 {
        struct mlx4_en_cq *cq = container_of(napi, struct mlx4_en_cq, napi);
-       struct net_device *dev = cq->dev;
+       struct ether *dev = cq->dev;
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int clean_complete;
 
@@ -515,26 +515,26 @@ int mlx4_en_poll_tx_cq(struct napi_struct *napi, int budget)
 
 static struct mlx4_en_tx_desc *mlx4_en_bounce_to_desc(struct mlx4_en_priv *priv,
                                                      struct mlx4_en_tx_ring *ring,
-                                                     u32 index,
+                                                     uint32_t index,
                                                      unsigned int desc_size)
 {
-       u32 copy = (ring->size - index) * TXBB_SIZE;
+       uint32_t copy = (ring->size - index) * TXBB_SIZE;
        int i;
 
        for (i = desc_size - copy - 4; i >= 0; i -= 4) {
                if ((i & (TXBB_SIZE - 1)) == 0)
                        wmb();
 
-               *((u32 *) (ring->buf + i)) =
-                       *((u32 *) (ring->bounce_buf + copy + i));
+               *((uint32_t *) (ring->buf + i)) =
+                       *((uint32_t *) (ring->bounce_buf + copy + i));
        }
 
        for (i = copy - 4; i >= 4 ; i -= 4) {
                if ((i & (TXBB_SIZE - 1)) == 0)
                        wmb();
 
-               *((u32 *) (ring->buf + index * TXBB_SIZE + i)) =
-                       *((u32 *) (ring->bounce_buf + i));
+               *((uint32_t *) (ring->buf + index * TXBB_SIZE + i)) =
+                       *((uint32_t *) (ring->bounce_buf + i));
        }
 
        /* Return real descriptor location */
@@ -582,7 +582,7 @@ static int inline_size(const struct sk_buff *skb)
 
 static int get_real_size(const struct sk_buff *skb,
                         const struct skb_shared_info *shinfo,
-                        struct net_device *dev,
+                        struct ether *dev,
                         int *lso_header_size,
                         bool *inline_ok,
                         void **pfrag)
@@ -627,7 +627,7 @@ static int get_real_size(const struct sk_buff *skb,
 static void build_inline_wqe(struct mlx4_en_tx_desc *tx_desc,
                             const struct sk_buff *skb,
                             const struct skb_shared_info *shinfo,
-                            int real_size, u16 *vlan_tag,
+                            int real_size, uint16_t *vlan_tag,
                             int tx_ind, void *fragptr)
 {
        struct mlx4_wqe_inline_seg *inl = &tx_desc->inl;
@@ -669,17 +669,18 @@ static void build_inline_wqe(struct mlx4_en_tx_desc *tx_desc,
                                       skb_frag_size(&shinfo->frags[0]));
                }
 
-               dma_wmb();
+               bus_wmb();
                inl->byte_count = cpu_to_be32(1 << 31 | (skb->len - spc));
        }
 }
 
-u16 mlx4_en_select_queue(struct net_device *dev, struct sk_buff *skb,
-                        void *accel_priv, select_queue_fallback_t fallback)
+uint16_t mlx4_en_select_queue(struct ether *dev, struct sk_buff *skb,
+                             void *accel_priv,
+                             select_queue_fallback_t fallback)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
-       u16 rings_p_up = priv->num_tx_rings_p_up;
-       u8 up = 0;
+       uint16_t rings_p_up = priv->num_tx_rings_p_up;
+       uint8_t up = 0;
 
        if (dev->num_tc)
                return skb_tx_hash(dev, skb);
@@ -696,7 +697,7 @@ static void mlx4_bf_copy(void __iomem *dst, const void *src,
        __iowrite64_copy(dst, src, bytecnt / 8);
 }
 
-netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
+netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct ether *dev)
 {
        struct skb_shared_info *shinfo = skb_shinfo(skb);
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -709,9 +710,9 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
        int nr_txbb;
        int desc_size;
        int real_size;
-       u32 index, bf_index;
+       uint32_t index, bf_index;
        __be32 op_own;
-       u16 vlan_tag = 0;
+       uint16_t vlan_tag = 0;
        int i_frag;
        int lso_header_size;
        void *fragptr = NULL;
@@ -719,7 +720,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
        bool send_doorbell;
        bool stop_queue;
        bool inline_ok;
-       u32 ring_cons;
+       uint32_t ring_cons;
 
        if (!priv->port_up)
                goto tx_drop;
@@ -752,7 +753,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
 
        /* Track current inflight packets for performance analysis */
        AVG_PERF_COUNTER(priv->pstats.inflight_avg,
-                        (u32)(ring->prod - ring_cons - 1));
+                        (uint32_t)(ring->prod - ring_cons - 1));
 
        /* Packet is good - grab an index and transmit it */
        index = ring->prod & ring->size_mask;
@@ -790,7 +791,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
 
        if (!tx_info->inl) {
                dma_addr_t dma = 0;
-               u32 byte_count = 0;
+               uint32_t byte_count = 0;
 
                /* Map fragments if any */
                for (i_frag = shinfo->nr_frags - 1; i_frag >= 0; i_frag--) {
@@ -806,7 +807,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
 
                        data->addr = cpu_to_be64(dma);
                        data->lkey = ring->mr_key;
-                       dma_wmb();
+                       bus_wmb();
                        data->byte_count = cpu_to_be32(byte_count);
                        --data;
                }
@@ -823,7 +824,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
 
                        data->addr = cpu_to_be64(dma);
                        data->lkey = ring->mr_key;
-                       dma_wmb();
+                       bus_wmb();
                        data->byte_count = cpu_to_be32(byte_count);
                }
                /* tx completion can avoid cache line miss for common cases */
@@ -893,7 +894,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                op_own = cpu_to_be32(MLX4_OPCODE_SEND) |
                        ((ring->prod & ring->size) ?
                         cpu_to_be32(MLX4_EN_BIT_DESC_OWN) : 0);
-               tx_info->nr_bytes = max_t(unsigned int, skb->len, ETH_ZLEN);
+               tx_info->nr_bytes = MAX_T(unsigned int, skb->len, ETH_ZLEN);
                ring->packets++;
        }
        ring->bytes += tx_info->nr_bytes;
@@ -936,11 +937,11 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                tx_desc->ctrl.bf_qpn = ring->doorbell_qpn |
                                       cpu_to_be32(real_size);
 
-               op_own |= htonl((bf_index & 0xffff) << 8);
+               op_own |= cpu_to_be32((bf_index & 0xffff) << 8);
                /* Ensure new descriptor hits memory
                 * before setting ownership of this descriptor to HW
                 */
-               dma_wmb();
+               bus_wmb();
                tx_desc->ctrl.owner_opcode = op_own;
 
                wmb();
@@ -960,7 +961,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                /* Ensure new descriptor hits memory
                 * before setting ownership of this descriptor to HW
                 */
-               dma_wmb();
+               bus_wmb();
                tx_desc->ctrl.owner_opcode = op_own;
                if (send_doorbell) {
                        wmb();
@@ -970,7 +971,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                         * endianness.
                         */
 #if defined(__LITTLE_ENDIAN)
-                       iowrite32(
+                       write32(
 #else
                        iowrite32be(
 #endif
@@ -988,7 +989,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev)
                 * Need a memory barrier to make sure ring->cons was not
                 * updated before queue was stopped.
                 */
-               smp_rmb();
+               rmb();
 
                ring_cons = ACCESS_ONCE(ring->cons);
                if (unlikely(((int)(ring->prod - ring_cons)) <=
index 2619c9f..b9312e3 100644 (file)
@@ -83,9 +83,9 @@ enum {
                               (1ull << MLX4_EVENT_TYPE_FLR_EVENT)          | \
                               (1ull << MLX4_EVENT_TYPE_FATAL_WARNING))
 
-static u64 get_async_ev_mask(struct mlx4_dev *dev)
+static uint64_t get_async_ev_mask(struct mlx4_dev *dev)
 {
-       u64 async_ev_mask = MLX4_ASYNC_EVENT_MASK;
+       uint64_t async_ev_mask = MLX4_ASYNC_EVENT_MASK;
        if (dev->caps.flags & MLX4_DEV_CAP_FLAG_PORT_MNG_CHG_EV)
                async_ev_mask |= (1ull << MLX4_EVENT_TYPE_PORT_MNG_CHG_EVENT);
        if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT)
@@ -96,15 +96,16 @@ static u64 get_async_ev_mask(struct mlx4_dev *dev)
 
 static void eq_set_ci(struct mlx4_eq *eq, int req_not)
 {
-       __raw_writel((__force u32) cpu_to_be32((eq->cons_index & 0xffffff) |
-                                              req_not << 31),
+       __raw_write32((__force uint32_t) cpu_to_be32((eq->cons_index & 0xffffff) |
+                                                   req_not << 31),
                     eq->doorbell);
        /* We still want ordering, just not swabbing, so add a barrier */
        mb();
 }
 
-static struct mlx4_eqe *get_eqe(struct mlx4_eq *eq, u32 entry, u8 eqe_factor,
-                               u8 eqe_size)
+static struct mlx4_eqe *get_eqe(struct mlx4_eq *eq, uint32_t entry,
+                               uint8_t eqe_factor,
+                               uint8_t eqe_size)
 {
        /* (entry & (eq->nent - 1)) gives us a cyclic array */
        unsigned long offset = (entry & (eq->nent - 1)) * eqe_size;
@@ -118,7 +119,8 @@ static struct mlx4_eqe *get_eqe(struct mlx4_eq *eq, u32 entry, u8 eqe_factor,
        return eq->page_list[offset / PAGE_SIZE].buf + (offset + (eqe_factor ? MLX4_EQ_ENTRY_SIZE : 0)) % PAGE_SIZE;
 }
 
-static struct mlx4_eqe *next_eqe_sw(struct mlx4_eq *eq, u8 eqe_factor, u8 size)
+static struct mlx4_eqe *next_eqe_sw(struct mlx4_eq *eq, uint8_t eqe_factor,
+                                   uint8_t size)
 {
        struct mlx4_eqe *eqe = get_eqe(eq, eq->cons_index, eqe_factor, size);
        return !!(eqe->owner & 0x80) ^ !!(eq->cons_index & eq->nent) ? NULL : eqe;
@@ -144,7 +146,7 @@ void mlx4_gen_slave_eqe(struct work_struct *work)
        struct mlx4_dev *dev = &priv->dev;
        struct mlx4_slave_event_eq *slave_eq = &mfunc->master.slave_eq;
        struct mlx4_eqe *eqe;
-       u8 slave;
+       uint8_t slave;
        int i;
 
        for (eqe = next_slave_event_eqe(slave_eq); eqe;
@@ -168,33 +170,34 @@ void mlx4_gen_slave_eqe(struct work_struct *work)
 }
 
 
-static void slave_event(struct mlx4_dev *dev, u8 slave, struct mlx4_eqe *eqe)
+static void slave_event(struct mlx4_dev *dev, uint8_t slave,
+                       struct mlx4_eqe *eqe)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_slave_event_eq *slave_eq = &priv->mfunc.master.slave_eq;
        struct mlx4_eqe *s_eqe;
        unsigned long flags;
 
-       spin_lock_irqsave(&slave_eq->event_lock, flags);
+       spin_lock_irqsave(&slave_eq->event_lock);
        s_eqe = &slave_eq->event_eqe[slave_eq->prod & (SLAVE_EVENT_EQ_SIZE - 1)];
        if ((!!(s_eqe->owner & 0x80)) ^
            (!!(slave_eq->prod & SLAVE_EVENT_EQ_SIZE))) {
                mlx4_warn(dev, "Master failed to generate an EQE for slave: %d. No free EQE on slave events queue\n",
                          slave);
-               spin_unlock_irqrestore(&slave_eq->event_lock, flags);
+               spin_unlock_irqsave(&slave_eq->event_lock);
                return;
        }
 
        memcpy(s_eqe, eqe, dev->caps.eqe_size - 1);
        s_eqe->slave_id = slave;
        /* ensure all information is written before setting the ownersip bit */
-       dma_wmb();
+       bus_wmb();
        s_eqe->owner = !!(slave_eq->prod & SLAVE_EVENT_EQ_SIZE) ? 0x0 : 0x80;
        ++slave_eq->prod;
 
        queue_work(priv->mfunc.master.comm_wq,
                   &priv->mfunc.master.slave_event_work);
-       spin_unlock_irqrestore(&slave_eq->event_lock, flags);
+       spin_unlock_irqsave(&slave_eq->event_lock);
 }
 
 static void mlx4_slave_event(struct mlx4_dev *dev, int slave,
@@ -210,7 +213,7 @@ static void mlx4_slave_event(struct mlx4_dev *dev, int slave,
        slave_event(dev, slave, eqe);
 }
 
-int mlx4_gen_pkey_eqe(struct mlx4_dev *dev, int slave, u8 port)
+int mlx4_gen_pkey_eqe(struct mlx4_dev *dev, int slave, uint8_t port)
 {
        struct mlx4_eqe eqe;
 
@@ -230,7 +233,7 @@ int mlx4_gen_pkey_eqe(struct mlx4_dev *dev, int slave, u8 port)
 }
 EXPORT_SYMBOL(mlx4_gen_pkey_eqe);
 
-int mlx4_gen_guid_change_eqe(struct mlx4_dev *dev, int slave, u8 port)
+int mlx4_gen_guid_change_eqe(struct mlx4_dev *dev, int slave, uint8_t port)
 {
        struct mlx4_eqe eqe;
 
@@ -247,8 +250,9 @@ int mlx4_gen_guid_change_eqe(struct mlx4_dev *dev, int slave, u8 port)
 }
 EXPORT_SYMBOL(mlx4_gen_guid_change_eqe);
 
-int mlx4_gen_port_state_change_eqe(struct mlx4_dev *dev, int slave, u8 port,
-                                  u8 port_subtype_change)
+int mlx4_gen_port_state_change_eqe(struct mlx4_dev *dev, int slave,
+                                  uint8_t port,
+                                  uint8_t port_subtype_change)
 {
        struct mlx4_eqe eqe;
 
@@ -267,7 +271,8 @@ int mlx4_gen_port_state_change_eqe(struct mlx4_dev *dev, int slave, u8 port,
 }
 EXPORT_SYMBOL(mlx4_gen_port_state_change_eqe);
 
-enum slave_port_state mlx4_get_slave_port_state(struct mlx4_dev *dev, int slave, u8 port)
+enum slave_port_state mlx4_get_slave_port_state(struct mlx4_dev *dev, int slave,
+                                               uint8_t port)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_slave_state *s_state = priv->mfunc.master.slave_state;
@@ -283,7 +288,8 @@ enum slave_port_state mlx4_get_slave_port_state(struct mlx4_dev *dev, int slave,
 }
 EXPORT_SYMBOL(mlx4_get_slave_port_state);
 
-static int mlx4_set_slave_port_state(struct mlx4_dev *dev, int slave, u8 port,
+static int mlx4_set_slave_port_state(struct mlx4_dev *dev, int slave,
+                                    uint8_t port,
                                     enum slave_port_state state)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
@@ -301,7 +307,7 @@ static int mlx4_set_slave_port_state(struct mlx4_dev *dev, int slave, u8 port,
        return 0;
 }
 
-static void set_all_slave_state(struct mlx4_dev *dev, u8 port, int event)
+static void set_all_slave_state(struct mlx4_dev *dev, uint8_t port, int event)
 {
        int i;
        enum slave_port_gen_event gen_event;
@@ -323,7 +329,7 @@ static void set_all_slave_state(struct mlx4_dev *dev, u8 port, int event)
                MLX4_PORT_STATE_IB_EVENT_GID_INVALID
 ***************************************************************************/
 int set_and_calc_slave_port_state(struct mlx4_dev *dev, int slave,
-                                 u8 port, int event,
+                                 uint8_t port, int event,
                                  enum slave_port_gen_event *gen_event)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
@@ -344,7 +350,7 @@ int set_and_calc_slave_port_state(struct mlx4_dev *dev, int slave,
        }
 
        ctx = &priv->mfunc.master.slave_state[slave];
-       spin_lock_irqsave(&ctx->lock, flags);
+       spin_lock_irqsave(&ctx->lock);
 
        switch (cur_state) {
        case SLAVE_PORT_DOWN:
@@ -382,13 +388,13 @@ int set_and_calc_slave_port_state(struct mlx4_dev *dev, int slave,
        ret = mlx4_get_slave_port_state(dev, slave, port);
 
 out:
-       spin_unlock_irqrestore(&ctx->lock, flags);
+       spin_unlock_irqsave(&ctx->lock);
        return ret;
 }
 
 EXPORT_SYMBOL(set_and_calc_slave_port_state);
 
-int mlx4_gen_slaves_port_mgt_ev(struct mlx4_dev *dev, u8 port, int attr)
+int mlx4_gen_slaves_port_mgt_ev(struct mlx4_dev *dev, uint8_t port, int attr)
 {
        struct mlx4_eqe eqe;
 
@@ -398,7 +404,7 @@ int mlx4_gen_slaves_port_mgt_ev(struct mlx4_dev *dev, u8 port, int attr)
        eqe.subtype = MLX4_DEV_PMC_SUBTYPE_PORT_INFO;
        eqe.event.port_mgmt_change.port = port;
        eqe.event.port_mgmt_change.params.port_info.changed_attr =
-               cpu_to_be32((u32) attr);
+               cpu_to_be32((uint32_t) attr);
 
        slave_event(dev, ALL_SLAVES, &eqe);
        return 0;
@@ -436,10 +442,10 @@ void mlx4_master_handle_slave_flr(struct work_struct *work)
                            MLX4_INTERFACE_STATE_UP)
                                mlx4_delete_all_resources_for_slave(dev, i);
                        /*return the slave to running mode*/
-                       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock, flags);
+                       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock);
                        slave_state[i].last_cmd = MLX4_COMM_CMD_RESET;
                        slave_state[i].is_slave_going_down = 0;
-                       spin_unlock_irqrestore(&priv->mfunc.master.slave_state_lock, flags);
+                       spin_unlock_irqsave(&priv->mfunc.master.slave_state_lock);
                        /*notify the FW:*/
                        err = mlx4_cmd(dev, 0, i, 0, MLX4_CMD_INFORM_FLR_DONE,
                                       MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
@@ -460,8 +466,8 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
        int port;
        int slave = 0;
        int ret;
-       u32 flr_slave;
-       u8 update_slave_state;
+       uint32_t flr_slave;
+       uint8_t update_slave_state;
        int i;
        enum slave_port_gen_event gen_event;
        unsigned long flags;
@@ -473,7 +479,7 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                 * Make sure we read EQ entry contents after we've
                 * checked the ownership bit.
                 */
-               dma_rmb();
+               bus_rmb();
 
                switch (eqe->type) {
                case MLX4_EVENT_TYPE_COMP:
@@ -695,13 +701,13 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                        } else
                                update_slave_state = 1;
 
-                       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock, flags);
+                       spin_lock_irqsave(&priv->mfunc.master.slave_state_lock);
                        if (update_slave_state) {
                                priv->mfunc.master.slave_state[flr_slave].active = false;
                                priv->mfunc.master.slave_state[flr_slave].last_cmd = MLX4_COMM_CMD_FLR;
                                priv->mfunc.master.slave_state[flr_slave].is_slave_going_down = 1;
                        }
-                       spin_unlock_irqrestore(&priv->mfunc.master.slave_state_lock, flags);
+                       spin_unlock_irqsave(&priv->mfunc.master.slave_state_lock);
                        mlx4_dispatch_event(dev, MLX4_DEV_EVENT_SLAVE_SHUTDOWN,
                                            flr_slave);
                        queue_work(priv->mfunc.master.comm_wq,
@@ -797,14 +803,14 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
        return eqes_found;
 }
 
-static irqreturn_t mlx4_interrupt(int irq, void *dev_ptr)
+static void mlx4_interrupt(struct hw_trapframe *hw_tf, void *dev_ptr)
 {
        struct mlx4_dev *dev = dev_ptr;
        struct mlx4_priv *priv = mlx4_priv(dev);
        int work = 0;
        int i;
 
-       writel(priv->eq_table.clr_mask, priv->eq_table.clr_int);
+       write32(priv->eq_table.clr_mask, priv->eq_table.clr_int);
 
        for (i = 0; i < dev->caps.num_comp_vectors + 1; ++i)
                work |= mlx4_eq_int(dev, &priv->eq_table.eq[i]);
@@ -812,7 +818,7 @@ static irqreturn_t mlx4_interrupt(int irq, void *dev_ptr)
        return IRQ_RETVAL(work);
 }
 
-static irqreturn_t mlx4_msi_x_interrupt(int irq, void *eq_ptr)
+static void mlx4_msi_x_interrupt(struct hw_trapframe *hw_tf, void *eq_ptr)
 {
        struct mlx4_eq  *eq  = eq_ptr;
        struct mlx4_dev *dev = eq->dev;
@@ -820,7 +826,7 @@ static irqreturn_t mlx4_msi_x_interrupt(int irq, void *eq_ptr)
        mlx4_eq_int(dev, eq);
 
        /* MSI-X vectors always belong to us */
-       return IRQ_HANDLED;
+       return;
 }
 
 int mlx4_MAP_EQ_wrapper(struct mlx4_dev *dev, int slave,
@@ -832,9 +838,9 @@ int mlx4_MAP_EQ_wrapper(struct mlx4_dev *dev, int slave,
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_slave_event_eq_info *event_eq =
                priv->mfunc.master.slave_state[slave].event_eq;
-       u32 in_modifier = vhcr->in_modifier;
-       u32 eqn = in_modifier & 0x3FF;
-       u64 in_param =  vhcr->in_param;
+       uint32_t in_modifier = vhcr->in_modifier;
+       uint32_t eqn = in_modifier & 0x3FF;
+       uint64_t in_param =  vhcr->in_param;
        int err = 0;
        int i;
 
@@ -850,7 +856,7 @@ int mlx4_MAP_EQ_wrapper(struct mlx4_dev *dev, int slave,
        return err;
 }
 
-static int mlx4_MAP_EQ(struct mlx4_dev *dev, u64 event_mask, int unmap,
+static int mlx4_MAP_EQ(struct mlx4_dev *dev, uint64_t event_mask, int unmap,
                        int eq_num)
 {
        return mlx4_cmd(dev, event_mask, (unmap << 31) | eq_num,
@@ -918,34 +924,34 @@ static void mlx4_unmap_uar(struct mlx4_dev *dev)
 }
 
 static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
-                         u8 intr, struct mlx4_eq *eq)
+                         uint8_t intr, struct mlx4_eq *eq)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_cmd_mailbox *mailbox;
        struct mlx4_eq_context *eq_context;
        int npages;
-       u64 *dma_list = NULL;
+       uint64_t *dma_list = NULL;
        dma_addr_t t;
-       u64 mtt_addr;
+       uint64_t mtt_addr;
        int err = -ENOMEM;
        int i;
 
        eq->dev   = dev;
-       eq->nent  = roundup_pow_of_two(max(nent, 2));
+       eq->nent  = ROUNDUPPWR2(MAX(nent, 2));
        /* CX3 is capable of extending the CQE/EQE from 32 to 64 bytes, with
         * strides of 64B,128B and 256B.
         */
        npages = PAGE_ALIGN(eq->nent * dev->caps.eqe_size) / PAGE_SIZE;
 
        eq->page_list = kmalloc(npages * sizeof *eq->page_list,
-                               GFP_KERNEL);
+                               KMALLOC_WAIT);
        if (!eq->page_list)
                goto err_out;
 
        for (i = 0; i < npages; ++i)
                eq->page_list[i].buf = NULL;
 
-       dma_list = kmalloc(npages * sizeof *dma_list, GFP_KERNEL);
+       dma_list = kmalloc(npages * sizeof *dma_list, KMALLOC_WAIT);
        if (!dma_list)
                goto err_out_free;
 
@@ -958,7 +964,7 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
                eq->page_list[i].buf = dma_alloc_coherent(&dev->persist->
                                                          pdev->dev,
                                                          PAGE_SIZE, &t,
-                                                         GFP_KERNEL);
+                                                         KMALLOC_WAIT);
                if (!eq->page_list[i].buf)
                        goto err_out_free_pages;
 
@@ -988,7 +994,7 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
 
        eq_context->flags         = cpu_to_be32(MLX4_EQ_STATUS_OK   |
                                                MLX4_EQ_STATE_ARMED);
-       eq_context->log_eq_size   = ilog2(eq->nent);
+       eq_context->log_eq_size   = LOG2_UP(eq->nent);
        eq_context->intr          = intr;
        eq_context->log_page_size = PAGE_SHIFT - MLX4_ICM_PAGE_SHIFT;
 
@@ -1009,7 +1015,7 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
 
        INIT_LIST_HEAD(&eq->tasklet_ctx.list);
        INIT_LIST_HEAD(&eq->tasklet_ctx.process_list);
-       spin_lock_init(&eq->tasklet_ctx.lock);
+       spinlock_init_irqsave(&eq->tasklet_ctx.lock);
        tasklet_init(&eq->tasklet_ctx.task, mlx4_cq_tasklet_cb,
                     (unsigned long)&eq->tasklet_ctx);
 
@@ -1124,8 +1130,8 @@ int mlx4_alloc_eq_table(struct mlx4_dev *dev)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
 
-       priv->eq_table.eq = kcalloc(dev->caps.num_eqs - dev->caps.reserved_eqs,
-                                   sizeof *priv->eq_table.eq, GFP_KERNEL);
+       priv->eq_table.eq = kzmalloc((dev->caps.num_eqs - dev->caps.reserved_eqs) * (sizeof *priv->eq_table.eq),
+                                    KMALLOC_WAIT);
        if (!priv->eq_table.eq)
                return -ENOMEM;
 
@@ -1143,19 +1149,18 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
        int err;
        int i;
 
-       priv->eq_table.uar_map = kcalloc(mlx4_num_eq_uar(dev),
-                                        sizeof *priv->eq_table.uar_map,
-                                        GFP_KERNEL);
+       priv->eq_table.uar_map = kzmalloc((mlx4_num_eq_uar(dev)) * (sizeof *priv->eq_table.uar_map),
+                                         KMALLOC_WAIT);
        if (!priv->eq_table.uar_map) {
                err = -ENOMEM;
                goto err_out_free;
        }
 
        err = mlx4_bitmap_init(&priv->eq_table.bitmap,
-                              roundup_pow_of_two(dev->caps.num_eqs),
+                              ROUNDUPPWR2(dev->caps.num_eqs),
                               dev->caps.num_eqs - 1,
                               dev->caps.reserved_eqs,
-                              roundup_pow_of_two(dev->caps.num_eqs) -
+                              ROUNDUPPWR2(dev->caps.num_eqs) -
                               dev->caps.num_eqs);
        if (err)
                goto err_out_free;
@@ -1177,7 +1182,7 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
        priv->eq_table.irq_names =
                kmalloc(MLX4_IRQNAME_SIZE * (dev->caps.num_comp_vectors + 1 +
                                             dev->caps.comp_pool),
-                       GFP_KERNEL);
+                       KMALLOC_WAIT);
        if (!priv->eq_table.irq_names) {
                err = -ENOMEM;
                goto err_out_bitmap;
@@ -1237,9 +1242,10 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
 
                        eq_name = priv->eq_table.irq_names +
                                  i * MLX4_IRQNAME_SIZE;
-                       err = request_irq(priv->eq_table.eq[i].irq,
-                                         mlx4_msi_x_interrupt, 0, eq_name,
-                                         priv->eq_table.eq + i);
+                       err = register_irq(priv->eq_table.eq[i].irq,
+                                          mlx4_msi_x_interrupt,
+                                          priv->eq_table.eq + i,
+                                          pci_to_tbdf(PCIDEV));
                        if (err)
                                goto err_out_async;
 
@@ -1250,8 +1256,8 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
                         MLX4_IRQNAME_SIZE,
                         DRV_NAME "@pci:%s",
                         pci_name(dev->persist->pdev));
-               err = request_irq(dev->persist->pdev->irq, mlx4_interrupt,
-                                 IRQF_SHARED, priv->eq_table.irq_names, dev);
+               err = register_irq(dev->persist->pdev->irq, mlx4_interrupt,
+                                  dev, pci_to_tbdf(PCIDEV));
                if (err)
                        goto err_out_async;
 
@@ -1367,7 +1373,7 @@ int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
        struct mlx4_priv *priv = mlx4_priv(dev);
        int vec = 0, err = 0, i;
 
-       mutex_lock(&priv->msix_ctl.pool_lock);
+       qlock(&priv->msix_ctl.pool_lock);
        for (i = 0; !vec && i < dev->caps.comp_pool; i++) {
                if (~priv->msix_ctl.pool_bm & 1ULL << i) {
                        priv->msix_ctl.pool_bm |= 1ULL << i;
@@ -1383,10 +1389,10 @@ int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
                                        mlx4_warn(dev, "Failed adding irq rmap\n");
                        }
 #endif
-                       err = request_irq(priv->eq_table.eq[vec].irq,
-                                         mlx4_msi_x_interrupt, 0,
-                                         &priv->eq_table.irq_names[vec<<5],
-                                         priv->eq_table.eq + vec);
+                       err = register_irq(priv->eq_table.eq[vec].irq,
+                                          mlx4_msi_x_interrupt,
+                                          priv->eq_table.eq + vec,
+                                          pci_to_tbdf(PCIDEV));
                        if (err) {
                                /*zero out bit by fliping it*/
                                priv->msix_ctl.pool_bm ^= 1 << i;
@@ -1398,7 +1404,7 @@ int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
                        eq_set_ci(&priv->eq_table.eq[vec], 1);
                }
        }
-       mutex_unlock(&priv->msix_ctl.pool_lock);
+       qunlock(&priv->msix_ctl.pool_lock);
 
        if (vec) {
                *vector = vec;
@@ -1427,13 +1433,13 @@ void mlx4_release_eq(struct mlx4_dev *dev, int vec)
        if (likely(i >= 0)) {
                /*sanity check , making sure were not trying to free irq's
                  Belonging to a legacy EQ*/
-               mutex_lock(&priv->msix_ctl.pool_lock);
+               qlock(&priv->msix_ctl.pool_lock);
                if (priv->msix_ctl.pool_bm & 1ULL << i) {
                        free_irq(priv->eq_table.eq[vec].irq,
                                 &priv->eq_table.eq[vec]);
                        priv->msix_ctl.pool_bm &= ~(1ULL << i);
                }
-               mutex_unlock(&priv->msix_ctl.pool_lock);
+               qunlock(&priv->msix_ctl.pool_lock);
        }
 
 }
index e30bf57..04017d4 100644 (file)
@@ -56,12 +56,12 @@ MODULE_PARM_DESC(enable_qos, "Enable Enhanced QoS support (default: on)");
 #define MLX4_GET(dest, source, offset)                               \
        do {                                                          \
                void *__p = (char *) (source) + (offset);             \
-               u64 val;                                              \
+               uint64_t val;                                              \
                switch (sizeof (dest)) {                              \
-               case 1: (dest) = *(u8 *) __p;       break;            \
+               case 1: (dest) = *(uint8_t *) __p;          break;            \
                case 2: (dest) = be16_to_cpup(__p); break;            \
                case 4: (dest) = be32_to_cpup(__p); break;            \
-               case 8: val = get_unaligned((u64 *)__p);              \
+               case 8: val = get_unaligned((uint64_t *)__p);              \
                        (dest) = be64_to_cpu(val);  break;            \
                default: __buggy_use_of_MLX4_GET();                   \
                }                                                     \
@@ -71,7 +71,7 @@ MODULE_PARM_DESC(enable_qos, "Enable Enhanced QoS support (default: on)");
        do {                                                          \
                void *__d = ((char *) (dest) + (offset));             \
                switch (sizeof(source)) {                             \
-               case 1: *(u8 *) __d = (source);                break; \
+               case 1: *(uint8_t *) __d = (source);                   break; \
                case 2: *(__be16 *) __d = cpu_to_be16(source); break; \
                case 4: *(__be32 *) __d = cpu_to_be32(source); break; \
                case 8: *(__be64 *) __d = cpu_to_be64(source); break; \
@@ -79,7 +79,7 @@ MODULE_PARM_DESC(enable_qos, "Enable Enhanced QoS support (default: on)");
                }                                                     \
        } while (0)
 
-static void dump_dev_cap_flags(struct mlx4_dev *dev, u64 flags)
+static void dump_dev_cap_flags(struct mlx4_dev *dev, uint64_t flags)
 {
        static const char *fname[] = {
                [ 0] = "RC transport",
@@ -122,7 +122,7 @@ static void dump_dev_cap_flags(struct mlx4_dev *dev, u64 flags)
                        mlx4_dbg(dev, "    %s\n", fname[i]);
 }
 
-static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
+static void dump_dev_cap_flags2(struct mlx4_dev *dev, uint64_t flags)
 {
        static const char * const fname[] = {
                [0] = "RSS support",
@@ -165,7 +165,7 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
 int mlx4_MOD_STAT_CFG(struct mlx4_dev *dev, struct mlx4_mod_stat_cfg *cfg)
 {
        struct mlx4_cmd_mailbox *mailbox;
-       u32 *inbox;
+       uint32_t *inbox;
        int err = 0;
 
 #define MOD_STAT_CFG_IN_SIZE           0x100
@@ -191,10 +191,10 @@ int mlx4_MOD_STAT_CFG(struct mlx4_dev *dev, struct mlx4_mod_stat_cfg *cfg)
 int mlx4_QUERY_FUNC(struct mlx4_dev *dev, struct mlx4_func *func, int slave)
 {
        struct mlx4_cmd_mailbox *mailbox;
-       u32 *outbox;
-       u8 in_modifier;
-       u8 field;
-       u16 field16;
+       uint32_t *outbox;
+       uint8_t in_modifier;
+       uint8_t field;
+       uint16_t field16;
        int err;
 
 #define QUERY_FUNC_BUS_OFFSET                  0x00
@@ -250,8 +250,8 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
                                struct mlx4_cmd_info *cmd)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
-       u8      field, port;
-       u32     size, proxy_qp, qkey;
+