mlx4: Clean up to make it compile
authorXiao Jia <stfairy@gmail.com>
Thu, 17 Sep 2015 00:58:00 +0000 (17:58 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 23 Sep 2015 20:46:27 +0000 (16:46 -0400)
32 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_main.c
kern/drivers/net/mlx4/en_netdev.c
kern/drivers/net/mlx4/en_port.c
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_qos.c
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/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

index 016c89a..da0b158 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/mm.h>
-#include <linux/export.h>
-#include <linux/bitmap.h>
-#include <linux/dma-mapping.h>
-#include <linux/vmalloc.h>
-
+#include <linux_compat.h>
 #include "mlx4.h"
 
 uint32_t mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
@@ -598,7 +591,13 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
 {
        dma_addr_t t;
 
+#if 0 // AKAROS_PORT
        if (size <= max_direct) {
+#else
+       if (size > max_direct)
+               printd("size %p max_direct %p\n", size, max_direct);
+       if (1) {
+#endif
                buf->nbufs        = 1;
                buf->npages       = 1;
                buf->page_shift   = get_order(size) + PAGE_SHIFT;
@@ -616,6 +615,8 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
 
                memset(buf->direct.buf, 0, size);
        } else {
+               panic("Disabled");
+#if 0 // AKAROS_PORT
                int i;
 
                buf->direct.buf  = NULL;
@@ -652,6 +653,7 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
                        if (!buf->direct.buf)
                                goto err_free;
                }
+#endif
        }
 
        return 0;
@@ -672,6 +674,8 @@ void mlx4_buf_free(struct mlx4_dev *dev, int size, struct mlx4_buf *buf)
                                  buf->direct.buf,
                                  buf->direct.map);
        else {
+               panic("Disabled");
+#if 0 // AKAROS_PORT
                if (BITS_PER_LONG == 64)
                        vunmap(buf->direct.buf);
 
@@ -682,6 +686,7 @@ void mlx4_buf_free(struct mlx4_dev *dev, int size, struct mlx4_buf *buf)
                                                  buf->page_list[i].buf,
                                                  buf->page_list[i].map);
                kfree(buf->page_list);
+#endif
        }
 }
 EXPORT_SYMBOL_GPL(mlx4_buf_free);
@@ -751,7 +756,11 @@ int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp
                if (!mlx4_alloc_db_from_pgdir(pgdir, db, order))
                        goto out;
 
+#if 0 // AKAROS_PORT
        pgdir = mlx4_alloc_db_pgdir(&dev->persist->pdev->dev, gfp);
+#else
+       pgdir = mlx4_alloc_db_pgdir(0, gfp);
+#endif
        if (!pgdir) {
                ret = -ENOMEM;
                goto out;
index b945e73..757974f 100644 (file)
@@ -31,9 +31,7 @@
  * SOFTWARE.
  */
 
-#include <linux/workqueue.h>
-#include <linux/module.h>
-
+#include <linux_compat.h>
 #include "mlx4.h"
 
 enum {
@@ -91,6 +89,8 @@ static int mlx4_reset_master(struct mlx4_dev *dev)
 
 static int mlx4_reset_slave(struct mlx4_dev *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
 #define COM_CHAN_RST_REQ_OFFSET 0x10
 #define COM_CHAN_RST_ACK_OFFSET 0x08
 
@@ -156,6 +156,7 @@ static int mlx4_reset_slave(struct mlx4_dev *dev)
        }
        mlx4_err(dev, "Fail to send reset over the communication channel\n");
        return -ETIMEDOUT;
+#endif
 }
 
 static int mlx4_comm_internal_err(uint32_t slave_read)
@@ -246,8 +247,12 @@ static void poll_catas(unsigned long dev_ptr)
                goto internal_err;
        }
 
+#if 0 // AKAROS_PORT
        mod_timer(&priv->catas_err.timer,
                  round_jiffies(jiffies + MLX4_CATAS_POLL_INTERVAL));
+#else
+       mod_timer(&priv->catas_err.timer, MLX4_CATAS_POLL_INTERVAL);
+#endif
        return;
 
 internal_err:
@@ -267,7 +272,11 @@ static void catas_reset(struct work_struct *work)
 void mlx4_start_catas_poll(struct mlx4_dev *dev)
 {
        struct mlx4_priv *priv = mlx4_priv(dev);
+#if 0 // AKAROS_PORT
        phys_addr_t addr;
+#else
+       void *addr;
+#endif
 
        INIT_LIST_HEAD(&priv->catas_err.list);
        init_timer(&priv->catas_err.timer);
@@ -288,8 +297,12 @@ void mlx4_start_catas_poll(struct mlx4_dev *dev)
 
        priv->catas_err.timer.data     = (unsigned long) dev;
        priv->catas_err.timer.function = poll_catas;
+#if 0 // AKAROS_PORT
        priv->catas_err.timer.expires  =
                round_jiffies(jiffies + MLX4_CATAS_POLL_INTERVAL);
+#else
+       priv->catas_err.timer.delay    = MLX4_CATAS_POLL_INTERVAL;
+#endif
        add_timer(&priv->catas_err.timer);
 }
 
index 9fa4ab4..b75f9ab 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/export.h>
-#include <linux/pci.h>
-#include <linux/errno.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 #include <linux/mlx4/device.h>
-#include <linux/semaphore.h>
-#include <rdma/ib_smi.h>
-#include <linux/delay.h>
-
-#include <asm/io.h>
-
+#include <linux/rdma/ib_smi.h>
 #include "mlx4.h"
 #include "fw.h"
 #include "fw_qos.h"
@@ -290,6 +280,8 @@ static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, uint8_t cmd,
                              uint16_t param,
                              unsigned long timeout)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        unsigned long end;
        int err = 0;
@@ -335,12 +327,15 @@ static int mlx4_comm_cmd_poll(struct mlx4_dev *dev, uint8_t cmd,
 out:
        up(&priv->cmd.poll_sem);
        return err;
+#endif
 }
 
 static int mlx4_comm_cmd_wait(struct mlx4_dev *dev, uint8_t vhcr_cmd,
                              uint16_t param, uint16_t op,
                              unsigned long timeout)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
        struct mlx4_cmd_context *context;
        unsigned long end;
@@ -405,6 +400,7 @@ out:
 
        up(&cmd->event_sem);
        return err;
+#endif
 }
 
 int mlx4_comm_cmd(struct mlx4_dev *dev, uint8_t cmd, uint16_t param,
@@ -459,9 +455,15 @@ static int mlx4_cmd_post(struct mlx4_dev *dev, uint64_t in_param,
                goto out;
        }
 
+#if 0 // AKAROS_PORT
        end = jiffies;
        if (event)
                end += msecs_to_jiffies(GO_BIT_TIMEOUT_MSECS);
+#else
+       end = 0;
+       if (event)
+               end += GO_BIT_TIMEOUT_MSECS;
+#endif
 
        while (cmd_pending(dev)) {
                if (pci_channel_offline(dev->persist->pdev)) {
@@ -472,7 +474,11 @@ static int mlx4_cmd_post(struct mlx4_dev *dev, uint64_t in_param,
                        goto out;
                }
 
+#if 0 // AKAROS_PORT
                if (time_after_eq(jiffies, end)) {
+#else
+               if ((end--) == 0) {
+#endif
                        mlx4_err(dev, "%s:cmd_pending failed\n", __func__);
                        goto out;
                }
@@ -628,8 +634,13 @@ static int mlx4_cmd_poll(struct mlx4_dev *dev, uint64_t in_param,
        if (err)
                goto out_reset;
 
+#if 0 // AKAROS_PORT
        end = msecs_to_jiffies(timeout) + jiffies;
        while (cmd_pending(dev) && time_before(jiffies, end)) {
+#else
+       end = timeout;
+       while (cmd_pending(dev) && end--) {
+#endif
                if (pci_channel_offline(dev->persist->pdev)) {
                        /*
                         * Device is going through error recovery
@@ -730,8 +741,12 @@ static int mlx4_cmd_wait(struct mlx4_dev *dev, uint64_t in_param,
        if (err)
                goto out_reset;
 
+#if 0 // AKAROS_PORT
        if (!wait_for_completion_timeout(&context->done,
                                         msecs_to_jiffies(timeout))) {
+#else
+       if (!wait_for_completion_timeout(&context->done, timeout)) {
+#endif
                mlx4_warn(dev, "command 0x%x timed out (go bit not cleared)\n",
                          op);
                if (op == MLX4_CMD_NOP) {
@@ -1840,6 +1855,8 @@ out:
 static int mlx4_master_immediate_activate_vlan_qos(struct mlx4_priv *priv,
                                            int slave, int port)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_vport_oper_state *vp_oper;
        struct mlx4_vport_state *vp_admin;
        struct mlx4_vf_immed_vlan_work *work;
@@ -1928,6 +1945,7 @@ static int mlx4_master_immediate_activate_vlan_qos(struct mlx4_priv *priv,
        queue_work(priv->mfunc.master.comm_wq, &work->work);
 
        return 0;
+#endif
 }
 
 static void mlx4_set_default_port_qos(struct mlx4_dev *dev, int port)
@@ -2270,6 +2288,8 @@ void mlx4_master_comm_channel(struct work_struct *work)
 
 static int sync_toggles(struct mlx4_dev *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        uint32_t wr_toggle;
        uint32_t rd_toggle;
@@ -2311,6 +2331,7 @@ static int sync_toggles(struct mlx4_dev *dev)
        priv->cmd.comm_toggle = 0;
 
        return 0;
+#endif
 }
 
 int mlx4_multi_func_init(struct mlx4_dev *dev)
@@ -3113,6 +3134,7 @@ int mlx4_get_vf_config(struct mlx4_dev *dev, int port, int vf, struct ifla_vf_in
                return -EINVAL;
 
        s_info = &priv->mfunc.master.vf_admin[slave].vport[port];
+#if 0 // AKAROS_PORT
        ivf->vf = vf;
 
        /* need to convert it to a func */
@@ -3134,6 +3156,7 @@ int mlx4_get_vf_config(struct mlx4_dev *dev, int port, int vf, struct ifla_vf_in
        ivf->min_tx_rate        = 0;
        ivf->spoofchk           = s_info->spoofchk;
        ivf->linkstate          = s_info->link_state;
+#endif
 
        return 0;
 }
@@ -3141,6 +3164,8 @@ EXPORT_SYMBOL_GPL(mlx4_get_vf_config);
 
 int mlx4_set_vf_link_state(struct mlx4_dev *dev, int port, int vf, int link_state)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_vport_state *s_info;
        int slave;
@@ -3184,6 +3209,7 @@ int mlx4_set_vf_link_state(struct mlx4_dev *dev, int port, int vf, int link_stat
                         "updating vf %d port %d no link state HW enforcment\n",
                         vf, port);
        return 0;
+#endif
 }
 EXPORT_SYMBOL_GPL(mlx4_set_vf_link_state);
 
index 4b6f6b9..fe73595 100644 (file)
@@ -34,9 +34,7 @@
  * SOFTWARE.
  */
 
-#include <linux/hardirq.h>
-#include <linux/export.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 #include <linux/mlx4/cq.h>
 
 #define MLX4_EQ_STATE_FIRED            (10 <<  8)
 
 #define TASKLET_MAX_TIME 2
+#if 0 // AKAROS_PORT
 #define TASKLET_MAX_TIME_JIFFIES msecs_to_jiffies(TASKLET_MAX_TIME)
+#endif
 
 void mlx4_cq_tasklet_cb(unsigned long data)
 {
        unsigned long flags;
+#if 0 // AKAROS_PORT
        unsigned long end = jiffies + TASKLET_MAX_TIME_JIFFIES;
+#else
+       unsigned long end = TASKLET_MAX_TIME;
+#endif
        struct mlx4_eq_tasklet *ctx = (struct mlx4_eq_tasklet *)data;
        struct mlx4_cq *mcq, *temp;
 
@@ -71,7 +75,11 @@ void mlx4_cq_tasklet_cb(unsigned long data)
                mcq->tasklet_ctx.comp(mcq);
                if (atomic_sub_and_test(&mcq->refcount, 1))
                        complete(&mcq->free);
+#if 0 // AKAROS_PORT
                if (time_after(jiffies, end))
+#else
+               if ((end--) == 0)
+#endif
                        break;
        }
 
@@ -343,7 +351,11 @@ int mlx4_cq_alloc(struct mlx4_dev *dev, int nent,
        INIT_LIST_HEAD(&cq->tasklet_ctx.list);
 
 
+#if 0 // AKAROS_PORT
        cq->irq = priv->eq_table.eq[cq->vector].irq;
+#else
+       cq->irq = -1; /* FIXME */
+#endif
        return 0;
 
 err_radix:
@@ -360,6 +372,8 @@ EXPORT_SYMBOL_GPL(mlx4_cq_alloc);
 
 void mlx4_cq_free(struct mlx4_dev *dev, struct mlx4_cq *cq)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_cq_table *cq_table = &priv->cq_table;
        int err;
@@ -379,6 +393,7 @@ void mlx4_cq_free(struct mlx4_dev *dev, struct mlx4_cq *cq)
        wait_for_completion(&cq->free);
 
        mlx4_cq_free_icm(dev, cq->cqn);
+#endif
 }
 EXPORT_SYMBOL_GPL(mlx4_cq_free);
 
index 97d3e85..12872bc 100644 (file)
  */
 
 #include <linux/mlx4/device.h>
-#include <linux/clocksource.h>
 
 #include "mlx4_en.h"
 
+#if 0 // AKAROS_PORT
 /* mlx4_en_read_clock - read raw cycle counter (to be used by time counter)
  */
 static uint64_t mlx4_en_read_clock(const struct cyclecounter *tc)
@@ -46,9 +46,12 @@ static uint64_t mlx4_en_read_clock(const struct cyclecounter *tc)
 
        return mlx4_read_clock(dev) & tc->mask;
 }
+#endif
 
 uint64_t mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        uint64_t hi, lo;
        struct mlx4_ts_cqe *ts_cqe = (struct mlx4_ts_cqe *)cqe;
 
@@ -56,12 +59,15 @@ uint64_t mlx4_en_get_cqe_ts(struct mlx4_cqe *cqe)
        hi = ((uint64_t)be32_to_cpu(ts_cqe->timestamp_hi) + !lo) << 16;
 
        return hi | lo;
+#endif
 }
 
 void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
                            struct skb_shared_hwtstamps *hwts,
                            uint64_t timestamp)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        unsigned long flags;
        uint64_t nsec;
 
@@ -71,6 +77,7 @@ void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
 
        memset(hwts, 0, sizeof(struct skb_shared_hwtstamps));
        hwts->hwtstamp = ns_to_ktime(nsec);
+#endif
 }
 
 /**
@@ -81,15 +88,20 @@ void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
  **/
 void mlx4_en_remove_timestamp(struct mlx4_en_dev *mdev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        if (mdev->ptp_clock) {
                ptp_clock_unregister(mdev->ptp_clock);
                mdev->ptp_clock = NULL;
                mlx4_info(mdev, "removed PHC\n");
        }
+#endif
 }
 
 void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        bool timeout = time_is_before_jiffies(mdev->last_overflow_check +
                                              mdev->overflow_period);
        unsigned long flags;
@@ -100,8 +112,10 @@ void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev)
                write_unlock_irqrestore(&mdev->clock_lock, flags);
                mdev->last_overflow_check = jiffies;
        }
+#endif
 }
 
+#if 0 // AKAROS_PORT
 /**
  * mlx4_en_phc_adjfreq - adjust the frequency of the hardware clock
  * @ptp: ptp clock structure
@@ -235,9 +249,12 @@ static const struct ptp_clock_info mlx4_en_ptp_clock_info = {
        .settime64      = mlx4_en_phc_settime,
        .enable         = mlx4_en_phc_enable,
 };
+#endif
 
 void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_dev *dev = mdev->dev;
        unsigned long flags;
        uint64_t ns, zero = 0;
@@ -282,4 +299,5 @@ void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev)
                mlx4_info(mdev, "registered PHC clock\n");
        }
 
+#endif
 }
index a9cb808..460b2b7 100644 (file)
@@ -122,7 +122,11 @@ int mlx4_en_activate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq,
                                        cq->ring);
                                /* Set IRQ for specific name (per ring) */
                                if (mlx4_assign_eq(mdev->dev, name, rmap,
+#if 0 // AKAROS_PORT
                                                   &cq->vector)) {
+#else
+                                                  (int*)&cq->vector)) {
+#endif
                                        cq->vector = (cq->ring + 1 + priv->port)
                                            % mdev->dev->caps.num_comp_vectors;
                                        mlx4_warn(mdev, "Failed assigning an EQ to %s, falling back to legacy EQ's\n",
@@ -164,6 +168,7 @@ int mlx4_en_activate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq,
        cq->mcq.comp  = cq->is_tx ? mlx4_en_tx_irq : mlx4_en_rx_irq;
        cq->mcq.event = mlx4_en_cq_event;
 
+#if 0 // AKAROS_PORT
        if (cq->is_tx) {
                netif_napi_add(cq->dev, &cq->napi, mlx4_en_poll_tx_cq,
                               NAPI_POLL_WEIGHT);
@@ -180,6 +185,7 @@ int mlx4_en_activate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq,
        }
 
        napi_enable(&cq->napi);
+#endif
 
        return 0;
 }
@@ -203,6 +209,8 @@ void mlx4_en_destroy_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq **pcq)
 
 void mlx4_en_deactivate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        napi_disable(&cq->napi);
        if (!cq->is_tx) {
                napi_hash_del(&cq->napi);
@@ -212,6 +220,7 @@ void mlx4_en_deactivate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)
        netif_napi_del(&cq->napi);
 
        mlx4_cq_free(priv->mdev->dev, &cq->mcq);
+#endif
 }
 
 /* Set rx cq moderation parameters */
index 8c749ec..99c15cd 100644 (file)
  *
  */
 
-#include <linux/cpumask.h>
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/netdevice.h>
-#include <linux/slab.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/driver.h>
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/cmd.h>
@@ -81,6 +76,7 @@ MLX4_EN_PARM_INT(inline_thold, MAX_INLINE,
 void en_print(const char *level, const struct mlx4_en_priv *priv,
              const char *format, ...)
 {
+#if 0 // AKAROS_PORT
        va_list args;
        struct va_format vaf;
 
@@ -96,6 +92,7 @@ void en_print(const char *level, const struct mlx4_en_priv *priv,
                       level, DRV_NAME, dev_name(&priv->mdev->pdev->dev),
                       priv->port, &vaf);
        va_end(args);
+#endif
 }
 
 void mlx4_en_update_loopback_state(struct ether *dev,
@@ -199,6 +196,8 @@ static void mlx4_en_event(struct mlx4_dev *dev, void *endev_ptr,
 
 static void mlx4_en_remove(struct mlx4_dev *dev, void *endev_ptr)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_dev *mdev = endev_ptr;
        int i;
 
@@ -222,6 +221,7 @@ static void mlx4_en_remove(struct mlx4_dev *dev, void *endev_ptr)
        if (mdev->nb.notifier_call)
                unregister_netdevice_notifier(&mdev->nb);
        kfree(mdev);
+#endif
 }
 
 static void *mlx4_en_add(struct mlx4_dev *dev)
@@ -248,7 +248,11 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
        spinlock_init_irqsave(&mdev->uar_lock);
 
        mdev->dev = dev;
+#if 0 // AKAROS_PORT
        mdev->dma_device = &dev->persist->pdev->dev;
+#else
+       mdev->dma_device = 0;
+#endif
        mdev->pdev = dev->persist->pdev;
        mdev->device_up = false;
 
@@ -278,9 +282,11 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH)
                mdev->port_cnt++;
 
+#if 0 // AKAROS_PORT
        /* Initialize time stamp mechanism */
        if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_TS)
                mlx4_en_init_timestamp(mdev);
+#endif
 
        /* Set default number of RX rings*/
        mlx4_en_set_num_rx_rings(mdev);
@@ -299,6 +305,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
 
        /* Setup ports */
 
+#if 0 // AKAROS_PORT
        /* Create a netdev for each port */
        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH) {
                mlx4_info(mdev, "Activating port:%d\n", i);
@@ -311,6 +318,7 @@ static void *mlx4_en_add(struct mlx4_dev *dev)
                mdev->nb.notifier_call = NULL;
                mlx4_err(mdev, "Failed to create notifier\n");
        }
+#endif
 
        return mdev;
 
@@ -365,6 +373,7 @@ static int __init mlx4_en_init(void)
        return mlx4_register_interface(&mlx4_en_interface);
 }
 
+#if 0 // AKAROS_PORT
 static void __exit mlx4_en_cleanup(void)
 {
        mlx4_unregister_interface(&mlx4_en_interface);
@@ -372,4 +381,4 @@ static void __exit mlx4_en_cleanup(void)
 
 module_init(mlx4_en_init);
 module_exit(mlx4_en_cleanup);
-
+#endif
index 1b2d304..bd7e036 100644 (file)
  *
  */
 
-#include <linux/etherdevice.h>
-#include <linux/tcp.h>
-#include <linux/if_vlan.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/hash.h>
-#include <net/ip.h>
-#include <net/busy_poll.h>
-#include <net/vxlan.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/driver.h>
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/cmd.h>
@@ -51,6 +42,8 @@
 
 int mlx4_en_setup_tc(struct ether *dev, uint8_t up)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int i;
        unsigned int offset = 0;
@@ -67,6 +60,7 @@ int mlx4_en_setup_tc(struct ether *dev, uint8_t up)
        }
 
        return 0;
+#endif
 }
 
 #ifdef CONFIG_NET_RX_BUSY_POLL
@@ -583,8 +577,14 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
        int *qpn = &priv->base_qpn;
        uint64_t mac = mlx4_mac_to_u64(priv->dev->ea);
 
+#if 0 // AKAROS_PORT
        en_dbg(DRV, priv, "Registering MAC: %pM for adding\n",
               priv->dev->ea);
+#else
+       en_dbg(DRV, priv, "Registering MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
+              priv->dev->ea[0], priv->dev->ea[1], priv->dev->ea[2],
+              priv->dev->ea[3], priv->dev->ea[4], priv->dev->ea[5]);
+#endif
        index = mlx4_register_mac(dev, priv->port, mac);
        if (index < 0) {
                err = index;
@@ -610,10 +610,12 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
        if (err)
                goto steer_err;
 
+#if 0 // AKAROS_PORT
        err = mlx4_en_tunnel_steer_add(priv, priv->dev->ea, *qpn,
                                       &priv->tunnel_reg_id);
        if (err)
                goto tunnel_err;
+#endif
 
        entry = kmalloc(sizeof(*entry), KMALLOC_WAIT);
        if (!entry) {
@@ -624,16 +626,24 @@ static int mlx4_en_get_qp(struct mlx4_en_priv *priv)
        memcpy(priv->current_mac, entry->mac, sizeof(priv->current_mac));
        entry->reg_id = reg_id;
 
+#if 0 // AKAROS_PORT
        hlist_add_head_rcu(&entry->hlist,
                           &priv->mac_hash[entry->mac[MLX4_EN_MAC_HASH_IDX]]);
+#else
+       hlist_add_head(&entry->hlist,
+                      &priv->mac_hash[entry->mac[MLX4_EN_MAC_HASH_IDX]]);
+       /* FIXME why is rcu significant? */
+#endif
 
        return 0;
 
 alloc_err:
        if (priv->tunnel_reg_id)
                mlx4_flow_detach(priv->mdev->dev, priv->tunnel_reg_id);
+#if 0 // AKAROS_PORT
 tunnel_err:
        mlx4_en_uc_steer_release(priv, priv->dev->ea, *qpn, reg_id);
+#endif
 
 steer_err:
        mlx4_qp_release_range(dev, *qpn, 1);
@@ -645,6 +655,8 @@ qp_err:
 
 static void mlx4_en_put_qp(struct mlx4_en_priv *priv)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_dev *dev = mdev->dev;
        int qpn = priv->base_qpn;
@@ -686,8 +698,10 @@ static void mlx4_en_put_qp(struct mlx4_en_priv *priv)
                mlx4_qp_release_range(dev, qpn, 1);
                priv->flags &= ~MLX4_EN_FLAG_FORCE_PROMISC;
        }
+#endif
 }
 
+#if 0 // AKAROS_PORT
 static int mlx4_en_replace_mac(struct mlx4_en_priv *priv, int qpn,
                               unsigned char *new_mac, unsigned char *prev_mac)
 {
@@ -778,6 +792,7 @@ static int mlx4_en_set_mac(struct ether *dev, void *addr)
 
        return err;
 }
+#endif
 
 static void mlx4_en_clear_list(struct ether *dev)
 {
@@ -790,6 +805,7 @@ static void mlx4_en_clear_list(struct ether *dev)
        }
 }
 
+#if 0 // AKAROS_PORT
 static void mlx4_en_cache_mclist(struct ether *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -1225,6 +1241,7 @@ static void mlx4_en_do_uc_filter(struct mlx4_en_priv *priv,
                        priv->port);
        }
 }
+#endif
 
 static void mlx4_en_do_set_rx_mode(struct work_struct *work)
 {
@@ -1253,6 +1270,7 @@ static void mlx4_en_do_set_rx_mode(struct work_struct *work)
                }
        }
 
+#if 0 // AKAROS_PORT
        if (dev->priv_flags & IFF_UNICAST_FLT)
                mlx4_en_do_uc_filter(priv, dev, mdev);
 
@@ -1268,6 +1286,7 @@ static void mlx4_en_do_set_rx_mode(struct work_struct *work)
                mlx4_en_clear_promisc_mode(priv, mdev);
 
        mlx4_en_do_multicast(priv, dev, mdev);
+#endif
 out:
        qunlock(&mdev->state_lock);
 }
@@ -1288,6 +1307,8 @@ static void mlx4_en_netpoll(struct ether *dev)
 
 static void mlx4_en_tx_timeout(struct ether *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        int i;
@@ -1306,6 +1327,7 @@ static void mlx4_en_tx_timeout(struct ether *dev)
        priv->port_stats.tx_timeout++;
        en_dbg(DRV, priv, "Scheduling watchdog\n");
        queue_work(mdev->workqueue, &priv->watchdog_task);
+#endif
 }
 
 
@@ -1367,6 +1389,8 @@ static void mlx4_en_set_default_moderation(struct mlx4_en_priv *priv)
 
 static void mlx4_en_auto_moderation(struct mlx4_en_priv *priv)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        unsigned long period = (unsigned long) (jiffies - priv->last_moder_jiffies);
        struct mlx4_en_cq *cq;
        unsigned long packets;
@@ -1426,10 +1450,13 @@ static void mlx4_en_auto_moderation(struct mlx4_en_priv *priv)
        }
 
        priv->last_moder_jiffies = jiffies;
+#endif
 }
 
 static void mlx4_en_do_get_stats(struct work_struct *work)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct delayed_work *delay = to_delayed_work(work);
        struct mlx4_en_priv *priv = container_of(delay, struct mlx4_en_priv,
                                                 stats_task);
@@ -1453,6 +1480,7 @@ static void mlx4_en_do_get_stats(struct work_struct *work)
                mdev->mac_removed[MLX4_MAX_PORTS + 1 - priv->port] = 0;
        }
        qunlock(&mdev->state_lock);
+#endif
 }
 
 /* mlx4_en_service_task - Run service task for tasks that needed to be done
@@ -1467,8 +1495,10 @@ static void mlx4_en_service_task(struct work_struct *work)
 
        qlock(&mdev->state_lock);
        if (mdev->device_up) {
+#if 0 // AKAROS_PORT
                if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_TS)
                        mlx4_en_ptp_overflow_check(mdev);
+#endif
 
                mlx4_en_recover_from_oom(priv);
                queue_delayed_work(mdev->workqueue, &priv->service_task,
@@ -1515,7 +1545,10 @@ static int mlx4_en_init_affinity_hint(struct mlx4_en_priv *priv, int ring_idx)
 
 static void mlx4_en_free_affinity_hint(struct mlx4_en_priv *priv, int ring_idx)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        free_cpumask_var(priv->rx_ring[ring_idx]->affinity_mask);
+#endif
 }
 
 int mlx4_en_start_port(struct ether *dev)
@@ -1538,9 +1571,11 @@ int mlx4_en_start_port(struct ether *dev)
 
        INIT_LIST_HEAD(&priv->mc_list);
        INIT_LIST_HEAD(&priv->curr_list);
+#if 0 // AKAROS_PORT
        INIT_LIST_HEAD(&priv->ethtool_list);
        memset(&priv->ethtool_rules[0], 0,
               sizeof(struct ethtool_flow_id) * MAX_NUM_OF_FS_RULES);
+#endif
 
        /* Calculate Rx buf size */
        dev->maxmtu = MIN(dev->maxmtu, priv->max_mtu);
@@ -1637,7 +1672,11 @@ int mlx4_en_start_port(struct ether *dev)
                        mlx4_en_deactivate_cq(priv, cq);
                        goto tx_err;
                }
+#if 0 // AKAROS_PORT
                tx_ring->tx_queue = netdev_get_tx_queue(dev, i);
+#else
+               tx_ring->tx_queue = 0; // TODO
+#endif
 
                /* Arm CQ for TX completions */
                mlx4_en_arm_cq(priv, cq);
@@ -1667,6 +1706,7 @@ int mlx4_en_start_port(struct ether *dev)
                goto tx_err;
        }
 
+#if 0 // AKAROS_PORT
        if (mdev->dev->caps.tunnel_offload_mode == MLX4_TUNNEL_OFFLOAD_MODE_VXLAN) {
                err = mlx4_SET_PORT_VXLAN(mdev->dev, priv->port, VXLAN_STEER_BY_OUTER_MAC, 1);
                if (err) {
@@ -1675,6 +1715,7 @@ int mlx4_en_start_port(struct ether *dev)
                        goto tx_err;
                }
        }
+#endif
 
        /* Init port */
        en_dbg(HW, priv, "Initializing port\n");
@@ -1703,8 +1744,10 @@ int mlx4_en_start_port(struct ether *dev)
                vxlan_get_rx_port(dev);
 #endif
        priv->port_up = true;
+#if 0 // AKAROS_PORT
        netif_tx_start_all_queues(dev);
        netif_device_attach(dev);
+#endif
 
        return 0;
 
@@ -1732,10 +1775,14 @@ cq_err:
 
 void mlx4_en_stop_port(struct ether *dev, int detach)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_mc_list *mclist, *tmp;
+#if 0 // AKAROS_PORT
        struct ethtool_flow_id *flow, *tmp_flow;
+#endif
        int i;
        uint8_t mc_list[16] = {0};
 
@@ -1807,6 +1854,7 @@ void mlx4_en_stop_port(struct ether *dev, int detach)
        /* Flush multicast filter */
        mlx4_SET_MCAST_FLTR(mdev->dev, priv->port, 0, 1, MLX4_MCAST_CONFIG);
 
+#if 0 // AKAROS_PORT
        /* Remove flow steering rules for the port*/
        if (mdev->dev->caps.steering_mode ==
            MLX4_STEERING_MODE_DEVICE_MANAGED) {
@@ -1817,6 +1865,7 @@ void mlx4_en_stop_port(struct ether *dev, int detach)
                        list_del(&flow->list);
                }
        }
+#endif
 
        mlx4_en_destroy_drop_qp(priv);
 
@@ -1855,6 +1904,7 @@ void mlx4_en_stop_port(struct ether *dev, int detach)
 
                mlx4_en_free_affinity_hint(priv, i);
        }
+#endif
 }
 
 static void mlx4_en_restart(struct work_struct *work)
@@ -1881,8 +1931,10 @@ static void mlx4_en_clear_stats(struct ether *dev)
        struct mlx4_en_dev *mdev = priv->mdev;
        int i;
 
+#if 0 // AKAROS_PORT
        if (mlx4_en_DUMP_ETH_STATS(mdev, priv->port, 1))
                en_dbg(HW, priv, "Failed dumping statistics\n");
+#endif
 
        memset(&priv->stats, 0, sizeof(priv->stats));
        memset(&priv->pstats, 0, sizeof(priv->pstats));
@@ -2046,6 +2098,8 @@ err:
 
 void mlx4_en_destroy_netdev(struct ether *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
 
@@ -2075,8 +2129,10 @@ void mlx4_en_destroy_netdev(struct ether *dev)
        kfree(priv->tx_cq);
 
        free_netdev(dev);
+#endif
 }
 
+#if 0 // AKAROS_PORT
 static int mlx4_en_change_mtu(struct ether *dev, int new_mtu)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
@@ -2513,6 +2569,7 @@ static const struct net_device_ops mlx4_netdev_ops_master = {
 #endif
        .ndo_set_tx_maxrate     = mlx4_en_set_tx_maxrate,
 };
+#endif
 
 struct mlx4_en_bond {
        struct work_struct work;
@@ -2523,6 +2580,8 @@ struct mlx4_en_bond {
 
 static void mlx4_en_bond_work(struct work_struct *work)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_bond *bond = container_of(work,
                                                     struct mlx4_en_bond,
                                                     work);
@@ -2550,11 +2609,14 @@ static void mlx4_en_bond_work(struct work_struct *work)
        }
        dev_put(bond->priv->dev);
        kfree(bond);
+#endif
 }
 
 static int mlx4_en_queue_bond_work(struct mlx4_en_priv *priv, int is_bonded,
                                   uint8_t v2p_p1, uint8_t v2p_p2)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_bond *bond = NULL;
 
        bond = kzmalloc(sizeof(*bond), 0);
@@ -2569,11 +2631,14 @@ static int mlx4_en_queue_bond_work(struct mlx4_en_priv *priv, int is_bonded,
        dev_hold(priv->dev);
        queue_work(priv->mdev->workqueue, &bond->work);
        return 0;
+#endif
 }
 
 int mlx4_en_netdev_event(struct notifier_block *this,
                         unsigned long event, void *ptr)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct ether *ndev = netdev_notifier_info_to_dev(ptr);
        uint8_t port = 0;
        struct mlx4_en_dev *mdev;
@@ -2684,6 +2749,7 @@ int mlx4_en_netdev_event(struct notifier_block *this,
 
        mlx4_en_queue_bond_work(priv, do_bond,
                                v2p_port1, v2p_port2);
+#endif
 
        return NOTIFY_DONE;
 }
@@ -2729,6 +2795,8 @@ void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,
                              uint8_t rx_ppp, uint8_t rx_pause,
                              uint8_t tx_ppp, uint8_t tx_pause)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        int last_i = 0;
 
        qlock_init(&stats_bitmap->mutex);
@@ -2762,6 +2830,7 @@ void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,
 
        if (!mlx4_is_slave(dev))
                bitmap_set(stats_bitmap->bitmap, last_i, NUM_PKT_STATS);
+#endif
 }
 
 int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
@@ -2773,6 +2842,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        int err;
        uint64_t mac_u64;
 
+#if 0 // AKAROS_PORT
        dev = alloc_etherdev_mqs(sizeof(struct mlx4_en_priv),
                                 MAX_TX_RINGS, MAX_RX_RINGS);
        if (dev == NULL)
@@ -2782,6 +2852,7 @@ 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);
+#endif
 
        /*
         * Initialize driver private data
@@ -2806,7 +2877,9 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
 
        priv->dev = dev;
        priv->mdev = mdev;
+#if 0 // AKAROS_PORT
        priv->ddev = &mdev->pdev->dev;
+#endif
        priv->prof = prof;
        priv->port = port;
        priv->port_up = false;
@@ -2895,6 +2968,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
        }
        priv->allocated = 1;
 
+#if 0 // AKAROS_PORT
        /*
         * Initialize netdev entry points
         */
@@ -2904,6 +2978,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                        {}
        netif_set_real_num_tx_queues(dev, priv->tx_ring_num);
        netif_set_real_num_rx_queues(dev, priv->rx_ring_num);
+#endif
 
        /*
         * Set driver features
@@ -2930,8 +3005,10 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
            mdev->dev->caps.dmfs_high_steer_mode != MLX4_STEERING_DMFS_A0_STATIC)
                dev->hw_features |= NETIF_F_NTUPLE;
 
+#if 0 // AKAROS_PORT
        if (mdev->dev->caps.steering_mode != MLX4_STEERING_MODE_A0)
                dev->priv_flags |= IFF_UNICAST_FLT;
+#endif
 
        /* Setting a default hash function value */
        if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RSS_TOP) {
@@ -2983,12 +3060,15 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                en_err(priv, "Failed Initializing port\n");
                goto out;
        }
+#if 0 // AKAROS_PORT
        queue_delayed_work(mdev->workqueue, &priv->stats_task, STATS_DELAY);
+#endif
 
        if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_TS)
                queue_delayed_work(mdev->workqueue, &priv->service_task,
                                   SERVICE_TASK_DELAY);
 
+#if 0 // AKAROS_PORT
        mlx4_en_set_stats_bitmap(mdev->dev, &priv->stats_bitmap,
                                 mdev->profile.prof[priv->port].rx_ppp,
                                 mdev->profile.prof[priv->port].rx_pause,
@@ -3000,6 +3080,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,
                en_err(priv, "Netdev registration failed for port %d\n", port);
                goto out;
        }
+#endif
 
        priv->registered = 1;
 
@@ -3055,9 +3136,11 @@ int mlx4_en_reset_config(struct ether *dev,
                /* RX time-stamping is OFF, update the RX vlan offload
                 * to the latest wanted state
                 */
+#if 0 // AKAROS_PORT
                if (dev->wanted_features & NETIF_F_HW_VLAN_CTAG_RX)
                        dev->feat |= NETIF_F_HW_VLAN_CTAG_RX;
                else
+#endif
                        dev->feat &= ~NETIF_F_HW_VLAN_CTAG_RX;
        }
 
@@ -3091,6 +3174,8 @@ int mlx4_en_reset_config(struct ether *dev,
 
 out:
        qunlock(&mdev->state_lock);
+#if 0 // AKAROS_PORT
        netdev_features_change(dev);
+#endif
        return err;
 }
index 3a04714..f7aa510 100644 (file)
  */
 
 
-#include <linux/if_vlan.h>
-
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/cmd.h>
-
 #include "en_port.h"
 #include "mlx4_en.h"
 
 
 int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, struct mlx4_en_priv *priv)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_cmd_mailbox *mailbox;
        struct mlx4_set_vlan_fltr_mbox *filter;
        int i;
@@ -67,6 +66,7 @@ int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, struct mlx4_en_priv *priv)
                       MLX4_CMD_TIME_CLASS_B, MLX4_CMD_WRAPPED);
        mlx4_free_cmd_mailbox(dev, mailbox);
        return err;
+#endif
 }
 
 int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, uint8_t port)
@@ -150,6 +150,8 @@ static unsigned long en_stats_adder(__be64 *start, __be64 *next, int num)
 int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, uint8_t port,
                           uint8_t reset)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        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]);
@@ -349,5 +351,6 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, uint8_t port,
 out:
        mlx4_free_cmd_mailbox(mdev->dev, mailbox);
        return err;
+#endif
 }
 
index 4c94112..c467611 100644 (file)
  *
  */
 
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
+#include <linux_compat.h>
 #include <linux/mlx4/qp.h>
-
 #include "mlx4_en.h"
 
 void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride,
@@ -89,6 +87,8 @@ int mlx4_en_map_buffer(struct mlx4_buf *buf)
        if (BITS_PER_LONG == 64 || buf->nbufs == 1)
                return 0;
 
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        pages = kmalloc(sizeof *pages * buf->nbufs, KMALLOC_WAIT);
        if (!pages)
                return -ENOMEM;
@@ -102,6 +102,7 @@ int mlx4_en_map_buffer(struct mlx4_buf *buf)
                return -ENOMEM;
 
        return 0;
+#endif
 }
 
 void mlx4_en_unmap_buffer(struct mlx4_buf *buf)
@@ -109,7 +110,10 @@ void mlx4_en_unmap_buffer(struct mlx4_buf *buf)
        if (BITS_PER_LONG == 64 || buf->nbufs == 1)
                return;
 
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        vunmap(buf->direct.buf);
+#endif
 }
 
 void mlx4_en_sqp_event(struct mlx4_qp *qp, enum mlx4_event event)
index 8f1316e..4692078 100644 (file)
  *
  */
 
-#include <net/busy_poll.h>
+#include <linux_compat.h>
 #include <linux/mlx4/cq.h>
-#include <linux/slab.h>
 #include <linux/mlx4/qp.h>
-#include <linux/skbuff.h>
-#include <linux/rculist.h>
-#include <linux/if_ether.h>
-#include <linux/if_vlan.h>
-#include <linux/vmalloc.h>
-#include <linux/irq.h>
-
-#if IS_ENABLED(CONFIG_IPV6)
-#include <net/ip6_checksum.h>
-#endif
-
 #include "mlx4_en.h"
 
 static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
@@ -82,8 +70,8 @@ static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
        /* Not doing get_page() for each frag is a big win
         * on asymetric workloads. Note we can not use atomic_set().
         */
-       atomic_add(page_alloc->page_size / frag_info->frag_stride - 1,
-                  &page->pg_kref.refcount);
+       atomic_add(&page->pg_kref.refcount,
+                  page_alloc->page_size / frag_info->frag_stride - 1);
        return 0;
 }
 
@@ -187,6 +175,8 @@ out:
 static void mlx4_en_destroy_allocator(struct mlx4_en_priv *priv,
                                      struct mlx4_en_rx_ring *ring)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_rx_alloc *page_alloc;
        int i;
 
@@ -206,6 +196,7 @@ static void mlx4_en_destroy_allocator(struct mlx4_en_priv *priv,
                }
                page_alloc->page = NULL;
        }
+#endif
 }
 
 static void mlx4_en_init_rx_desc(struct mlx4_en_priv *priv,
@@ -414,7 +405,10 @@ int mlx4_en_create_rx_ring(struct mlx4_en_priv *priv,
 err_hwq:
        mlx4_free_hwq_res(mdev->dev, &ring->wqres, ring->buf_size);
 err_info:
+       panic("Not implemented");
+#if 0 // AKAROS_PORT
        vfree(ring->rx_info);
+#endif
        ring->rx_info = NULL;
 err_ring:
        kfree(ring);
@@ -504,7 +498,10 @@ void mlx4_en_recover_from_oom(struct mlx4_en_priv *priv)
 
        for (ring = 0; ring < priv->rx_ring_num; ring++) {
                if (mlx4_en_is_ring_empty(priv->rx_ring[ring]))
+                       panic("Not implemented");
+#if 0 // AKAROS_PORT
                        napi_reschedule(&priv->rx_cq[ring]->napi);
+#endif
        }
 }
 
@@ -512,6 +509,8 @@ void mlx4_en_destroy_rx_ring(struct mlx4_en_priv *priv,
                             struct mlx4_en_rx_ring **pring,
                             uint32_t size, uint16_t stride)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_rx_ring *ring = *pring;
 
@@ -524,6 +523,7 @@ void mlx4_en_destroy_rx_ring(struct mlx4_en_priv *priv,
 #ifdef CONFIG_RFS_ACCEL
        mlx4_en_cleanup_filters(priv);
 #endif
+#endif
 }
 
 void mlx4_en_deactivate_rx_ring(struct mlx4_en_priv *priv,
@@ -536,6 +536,7 @@ void mlx4_en_deactivate_rx_ring(struct mlx4_en_priv *priv,
 }
 
 
+#if 0 // AKAROS_PORT
 static int mlx4_en_complete_rx_desc(struct mlx4_en_priv *priv,
                                    struct mlx4_en_rx_desc *rx_desc,
                                    struct mlx4_en_rx_alloc *frags,
@@ -579,8 +580,10 @@ fail:
        }
        return 0;
 }
+#endif
 
 
+#if 0 // AKAROS_PORT
 static struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv,
                                      struct mlx4_en_rx_desc *rx_desc,
                                      struct mlx4_en_rx_alloc *frags,
@@ -653,6 +656,7 @@ static void validate_loopback(struct mlx4_en_priv *priv, struct sk_buff *skb)
 out_loopback:
        dev_kfree_skb_any(skb);
 }
+#endif
 
 static void mlx4_en_refill_rx_buffers(struct mlx4_en_priv *priv,
                                     struct mlx4_en_rx_ring *ring)
@@ -668,6 +672,7 @@ static void mlx4_en_refill_rx_buffers(struct mlx4_en_priv *priv,
        }
 }
 
+#if 0 // AKAROS_PORT
 /* When hardware doesn't strip the vlan, we need to calculate the checksum
  * over it and add it to the hardware's checksum calculation
  */
@@ -750,6 +755,7 @@ static int check_csum(struct mlx4_cqe *cqe, struct sk_buff *skb, void *va,
 #endif
        return 0;
 }
+#endif
 
 int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
                          int budget)
@@ -807,6 +813,7 @@ int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
                        goto next;
                }
 
+#if 0 // AKAROS_PORT
                /* Check if we need to drop the packet if SRIOV is not enabled
                 * and not performing the selftest or flb disabled
                 */
@@ -841,6 +848,7 @@ int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
                                rcu_read_unlock();
                        }
                }
+#endif
 
                /*
                 * Packet is OK - process it.
@@ -849,8 +857,12 @@ int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
                length -= ring->fcs_del;
                ring->bytes += length;
                ring->packets++;
+#if 0 // AKAROS_PORT
                l2_tunnel = (dev->hw_enc_features & NETIF_F_RXCSUM) &&
                        (cqe->vlan_my_qpn & cpu_to_be32(MLX4_CQE_L2_TUNNEL));
+#else
+               l2_tunnel = 0;
+#endif
 
                if (likely(dev->feat & NETIF_F_RXCSUM)) {
                        if (cqe->status & cpu_to_be16(MLX4_CQE_STATUS_TCP |
@@ -879,6 +891,7 @@ int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
                        ring->csum_none++;
                }
 
+#if 0 // AKAROS_PORT
                /* This packet is eligible for GRO if it is:
                 * - DIX Ethernet (type interpretation)
                 * - TCP/IP (v4)
@@ -994,6 +1007,7 @@ int mlx4_en_process_rx_cq(struct ether *dev, struct mlx4_en_cq *cq,
                        napi_gro_receive(&cq->napi, skb);
                else
                        netif_receive_skb(skb);
+#endif
 
 next:
                for (nr = 0; nr < priv->num_frags; nr++)
@@ -1023,7 +1037,11 @@ void mlx4_en_rx_irq(struct mlx4_cq *mcq)
        struct mlx4_en_priv *priv = netdev_priv(cq->dev);
 
        if (likely(priv->port_up))
+#if 0 // AKAROS_PORT
                napi_schedule_irqoff(&cq->napi);
+#else
+               { /* TODO */ }
+#endif
        else
                mlx4_en_arm_cq(priv, cq);
 }
@@ -1043,6 +1061,7 @@ int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget)
 
        mlx4_en_cq_unlock_napi(cq);
 
+#if 0 // AKAROS_PORT
        /* If we used up all the quota - we're probably not done yet... */
        if (done == budget) {
                int cpu_curr;
@@ -1064,6 +1083,7 @@ int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget)
        }
        /* Done for now */
        napi_complete_done(napi, done);
+#endif
        mlx4_en_arm_cq(priv, cq);
        return done;
 }
@@ -1163,7 +1183,7 @@ int mlx4_en_create_drop_qp(struct mlx4_en_priv *priv)
        int err;
        uint32_t qpn;
 
-       err = mlx4_qp_reserve_range(priv->mdev->dev, 1, 1, &qpn,
+       err = mlx4_qp_reserve_range(priv->mdev->dev, 1, 1, (int *)&qpn,
                                    MLX4_RESERVE_A0_QP);
        if (err) {
                en_err(priv, "Failed reserving drop qpn\n");
index 79824b5..4658f13 100644 (file)
  *
  */
 
-#include <linux/kernel.h>
-#include <linux/ethtool.h>
-#include <linux/netdevice.h>
-#include <linux/delay.h>
-#include <linux/mlx4/driver.h>
-
 #include "mlx4_en.h"
 
 
@@ -48,6 +42,8 @@ static int mlx4_en_test_registers(struct mlx4_en_priv *priv)
 
 static int mlx4_en_test_loopback_xmit(struct mlx4_en_priv *priv)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct sk_buff *skb;
        struct ethhdr *ethh;
        unsigned char *packet;
@@ -76,6 +72,7 @@ static int mlx4_en_test_loopback_xmit(struct mlx4_en_priv *priv)
        /* xmit the pkt */
        err = mlx4_en_xmit(skb, priv->dev);
        return err;
+#endif
 }
 
 static int mlx4_en_test_loopback(struct mlx4_en_priv *priv)
@@ -152,6 +149,8 @@ static int mlx4_en_test_speed(struct mlx4_en_priv *priv)
 void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
                         uint64_t *buf)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct mlx4_en_dev *mdev = priv->mdev;
        int i, carrier_ok;
@@ -187,4 +186,5 @@ void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
                if (buf[i])
                        *flags |= ETH_TEST_FL_FAILED;
        }
+#endif
 }
index 7d476e0..1ece711 100644 (file)
  *
  */
 
-#include <asm/page.h>
 #include <linux/mlx4/cq.h>
-#include <linux/slab.h>
 #include <linux/mlx4/qp.h>
-#include <linux/skbuff.h>
-#include <linux/if_vlan.h>
-#include <linux/prefetch.h>
-#include <linux/vmalloc.h>
-#include <linux/tcp.h>
-#include <linux/ip.h>
-#include <linux/moduleparam.h>
-
 #include "mlx4_en.h"
 
 int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
@@ -126,8 +116,12 @@ int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
        }
        ring->qp.event = mlx4_en_sqp_event;
 
+#if 0 // AKAROS_PORT
        err = mlx4_bf_alloc(mdev->dev, &ring->bf, node);
        if (err) {
+#else
+       if (true) {
+#endif
                en_dbg(DRV, priv, "working without blueflame (%d)\n", err);
                ring->bf.uar = &mdev->priv_uar;
                ring->bf.uar->map = mdev->uar_map;
@@ -161,7 +155,9 @@ err_bounce:
        kfree(ring->bounce_buf);
        ring->bounce_buf = NULL;
 err_info:
+#if 0 // AKAROS_PORT
        kvfree(ring->tx_info);
+#endif
        ring->tx_info = NULL;
 err_ring:
        kfree(ring);
@@ -172,6 +168,8 @@ err_ring:
 void mlx4_en_destroy_tx_ring(struct mlx4_en_priv *priv,
                             struct mlx4_en_tx_ring **pring)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_dev *mdev = priv->mdev;
        struct mlx4_en_tx_ring *ring = *pring;
        en_dbg(DRV, priv, "Destroying tx ring, qpn: %d\n", ring->qpn);
@@ -188,6 +186,7 @@ void mlx4_en_destroy_tx_ring(struct mlx4_en_priv *priv,
        ring->tx_info = NULL;
        kfree(ring);
        *pring = NULL;
+#endif
 }
 
 int mlx4_en_activate_tx_ring(struct mlx4_en_priv *priv,
@@ -215,9 +214,11 @@ int mlx4_en_activate_tx_ring(struct mlx4_en_priv *priv,
 
        err = mlx4_qp_to_ready(mdev->dev, &ring->wqres.mtt, &ring->context,
                               &ring->qp, &ring->qp_state);
+#if 0 // AKAROS_PORT
        if (!cpumask_empty(&ring->affinity_mask))
                netif_set_xps_queue(priv->dev, &ring->affinity_mask,
                                    ring->queue_index);
+#endif
 
        return err;
 }
@@ -273,10 +274,11 @@ static uint32_t mlx4_en_free_tx_desc(struct mlx4_en_priv *priv,
        struct mlx4_en_tx_desc *tx_desc = ring->buf + index * TXBB_SIZE;
        struct mlx4_wqe_data_seg *data = (void *) tx_desc + tx_info->data_offset;
        void *end = ring->buf + ring->buf_size;
-       struct sk_buff *skb = tx_info->skb;
+       struct block *block = tx_info->block;
        int nr_maps = tx_info->nr_maps;
        int i;
 
+#if 0 // AKAROS_PORT
        /* We do not touch skb here, so prefetch skb->users location
         * to speedup consume_skb()
         */
@@ -288,6 +290,7 @@ static uint32_t mlx4_en_free_tx_desc(struct mlx4_en_priv *priv,
                mlx4_en_fill_hwtstamps(priv->mdev, &hwts, timestamp);
                skb_tstamp_tx(skb, &hwts);
        }
+#endif
 
        /* Optimize the common case when there are no wraparounds */
        if (likely((void *) tx_desc + tx_info->nr_txbb * TXBB_SIZE <= end)) {
@@ -338,13 +341,15 @@ static uint32_t mlx4_en_free_tx_desc(struct mlx4_en_priv *priv,
                        }
                }
        }
-       dev_consume_skb_any(skb);
+       freeb(block);
        return tx_info->nr_txbb;
 }
 
 
 int mlx4_en_free_tx_buf(struct ether *dev, struct mlx4_en_tx_ring *ring)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        int cnt = 0;
 
@@ -373,6 +378,7 @@ int mlx4_en_free_tx_buf(struct ether *dev, struct mlx4_en_tx_ring *ring)
                en_dbg(DRV, priv, "Freed %d uncompleted tx descriptors\n", cnt);
 
        return cnt;
+#endif
 }
 
 static bool mlx4_en_process_tx_cq(struct ether *dev,
@@ -402,7 +408,9 @@ static bool mlx4_en_process_tx_cq(struct ether *dev,
        if (!priv->port_up)
                return true;
 
+#if 0 // AKAROS_PORT
        netdev_txq_bql_complete_prefetchw(ring->tx_queue);
+#endif
 
        index = cons_index & size_mask;
        cqe = mlx4_en_get_cqe(buf, index, priv->cqe_size) + factor;
@@ -471,6 +479,7 @@ static bool mlx4_en_process_tx_cq(struct ether *dev,
        ACCESS_ONCE(ring->last_nr_txbb) = last_nr_txbb;
        ACCESS_ONCE(ring->cons) = ring_cons + txbbs_skipped;
 
+#if 0 // AKAROS_PORT
        netdev_tx_completed_queue(ring->tx_queue, packets, bytes);
 
        /*
@@ -481,6 +490,7 @@ static bool mlx4_en_process_tx_cq(struct ether *dev,
                netif_tx_wake_queue(ring->tx_queue);
                ring->wake_queue++;
        }
+#endif
        return done < budget;
 }
 
@@ -490,7 +500,11 @@ void mlx4_en_tx_irq(struct mlx4_cq *mcq)
        struct mlx4_en_priv *priv = netdev_priv(cq->dev);
 
        if (likely(priv->port_up))
+#if 0 // AKAROS_PORT
                napi_schedule_irqoff(&cq->napi);
+#else
+               { /* TODO */ }
+#endif
        else
                mlx4_en_arm_cq(priv, cq);
 }
@@ -541,6 +555,7 @@ static struct mlx4_en_tx_desc *mlx4_en_bounce_to_desc(struct mlx4_en_priv *priv,
        return ring->buf + index * TXBB_SIZE;
 }
 
+#if 0 // AKAROS_PORT
 /* Decide if skb can be inlined in tx descriptor to avoid dma mapping
  *
  * It seems strange we do not simply use skb_copy_bits().
@@ -673,11 +688,14 @@ static void build_inline_wqe(struct mlx4_en_tx_desc *tx_desc,
                inl->byte_count = cpu_to_be32(1 << 31 | (skb->len - spc));
        }
 }
+#endif
 
 uint16_t mlx4_en_select_queue(struct ether *dev, struct sk_buff *skb,
                              void *accel_priv,
                              select_queue_fallback_t fallback)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_en_priv *priv = netdev_priv(dev);
        uint16_t rings_p_up = priv->num_tx_rings_p_up;
        uint8_t up = 0;
@@ -689,14 +707,18 @@ uint16_t mlx4_en_select_queue(struct ether *dev, struct sk_buff *skb,
                up = skb_vlan_tag_get(skb) >> VLAN_PRIO_SHIFT;
 
        return fallback(dev, skb) % rings_p_up + up * rings_p_up;
+#endif
 }
 
+#if 0 // AKAROS_PORT
 static void mlx4_bf_copy(void __iomem *dst, const void *src,
                         unsigned int bytecnt)
 {
        __iowrite64_copy(dst, src, bytecnt / 8);
 }
+#endif
 
+#if 0 // AKAROS_PORT
 netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct ether *dev)
 {
        struct skb_shared_info *shinfo = skb_shinfo(skb);
@@ -971,7 +993,7 @@ netdev_tx_t mlx4_en_xmit(struct sk_buff *skb, struct ether *dev)
                         * endianness.
                         */
 #if defined(__LITTLE_ENDIAN)
-                       write32(
+                       iowrite32(
 #else
                        iowrite32be(
 #endif
@@ -1015,4 +1037,5 @@ tx_drop:
        priv->stats.tx_dropped++;
        return NETDEV_TX_OK;
 }
+#endif
 
index b9312e3..808a3d7 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/export.h>
-#include <linux/mm.h>
-#include <linux/dma-mapping.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
-#include <linux/cpu_rmap.h>
-
 #include "mlx4.h"
 #include "fw.h"
 
@@ -579,6 +572,8 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                                        continue;
                                                mlx4_dbg(dev, "%s: Sending MLX4_PORT_CHANGE_SUBTYPE_DOWN to slave: %d, port:%d\n",
                                                         __func__, i, port);
+                                               panic("Disabled");
+#if 0 // AKAROS_PORT
                                                s_info = &priv->mfunc.master.vf_oper[slave].vport[port].state;
                                                if (IFLA_VF_LINK_STATE_AUTO == s_info->link_state) {
                                                        eqe->event.port_change.port =
@@ -587,6 +582,7 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                                                | (mlx4_phys_to_slave_port(dev, i, port) << 28));
                                                        mlx4_slave_event(dev, i, eqe);
                                                }
+#endif
                                        } else {  /* IB port */
                                                set_and_calc_slave_port_state(dev, i, port,
                                                                              MLX4_PORT_STATE_DEV_EVENT_PORT_DOWN,
@@ -614,6 +610,8 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                                        continue;
                                                if (i == mlx4_master_func_num(dev))
                                                        continue;
+                                               panic("Disabled");
+#if 0 // AKAROS_PORT
                                                s_info = &priv->mfunc.master.vf_oper[slave].vport[port].state;
                                                if (IFLA_VF_LINK_STATE_AUTO == s_info->link_state) {
                                                        eqe->event.port_change.port =
@@ -622,6 +620,7 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
                                                                | (mlx4_phys_to_slave_port(dev, i, port) << 28));
                                                        mlx4_slave_event(dev, i, eqe);
                                                }
+#endif
                                        }
                                else /* IB port */
                                        /* port-up event will be sent to a slave when the
@@ -803,6 +802,7 @@ static int mlx4_eq_int(struct mlx4_dev *dev, struct mlx4_eq *eq)
        return eqes_found;
 }
 
+#if 0 // AKAROS_PORT
 static void mlx4_interrupt(struct hw_trapframe *hw_tf, void *dev_ptr)
 {
        struct mlx4_dev *dev = dev_ptr;
@@ -828,6 +828,7 @@ static void mlx4_msi_x_interrupt(struct hw_trapframe *hw_tf, void *eq_ptr)
        /* MSI-X vectors always belong to us */
        return;
 }
+#endif
 
 int mlx4_MAP_EQ_wrapper(struct mlx4_dev *dev, int slave,
                        struct mlx4_vhcr *vhcr,
@@ -1074,6 +1075,8 @@ static void mlx4_free_eq(struct mlx4_dev *dev,
 
 static void mlx4_free_irqs(struct mlx4_dev *dev)
 {
+       panic("Not implemented");
+#if 0 // AKAROS_PORT
        struct mlx4_eq_table *eq_table = &mlx4_priv(dev)->eq_table;
        struct mlx4_priv *priv = mlx4_priv(dev);
        int     i, vec;
@@ -1102,6 +1105,7 @@ static void mlx4_free_irqs(struct mlx4_dev *dev)
 
 
        kfree(eq_table->irq_names);
+#endif
 }
 
 static int mlx4_map_clr_int(struct mlx4_dev *dev)
@@ -1242,16 +1246,20 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
 
                        eq_name = priv->eq_table.irq_names +
                                  i * MLX4_IRQNAME_SIZE;
+#if 0 // AKAROS_PORT
                        err = register_irq(priv->eq_table.eq[i].irq,
                                           mlx4_msi_x_interrupt,
                                           priv->eq_table.eq + i,
                                           pci_to_tbdf(PCIDEV));
+#endif
                        if (err)
                                goto err_out_async;
 
                        priv->eq_table.eq[i].have_irq = 1;
                }
        } else {
+               panic("Disabled");
+#if 0 // AKAROS_PORT
                snprintf(priv->eq_table.irq_names,
                         MLX4_IRQNAME_SIZE,
                         DRV_NAME "@pci:%s",
@@ -1262,6 +1270,7 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
                        goto err_out_async;
 
                priv->eq_table.have_irq = 1;
+#endif
        }
 
        err = mlx4_MAP_EQ(dev, get_async_ev_mask(dev), 0,
@@ -1369,6 +1378,8 @@ EXPORT_SYMBOL(mlx4_test_interrupts);
 int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
                   int *vector)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
 
        struct mlx4_priv *priv = mlx4_priv(dev);
        int vec = 0, err = 0, i;
@@ -1413,19 +1424,25 @@ int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
                err = (i == dev->caps.comp_pool) ? -ENOSPC : err;
        }
        return err;
+#endif
 }
 EXPORT_SYMBOL(mlx4_assign_eq);
 
 int mlx4_eq_get_irq(struct mlx4_dev *dev, int vec)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
 
        return priv->eq_table.eq[vec].irq;
+#endif
 }
 EXPORT_SYMBOL(mlx4_eq_get_irq);
 
 void mlx4_release_eq(struct mlx4_dev *dev, int vec)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        /*bm index*/
        int i = vec - dev->caps.num_comp_vectors - 1;
@@ -1441,7 +1458,7 @@ void mlx4_release_eq(struct mlx4_dev *dev, int vec)
                }
                qunlock(&priv->msix_ctl.pool_lock);
        }
-
+#endif
 }
 EXPORT_SYMBOL(mlx4_release_eq);
 
index 04017d4..dc52012 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/etherdevice.h>
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
-#include <linux/module.h>
-#include <linux/cache.h>
-
 #include "fw.h"
 #include "icm.h"
 
@@ -1280,11 +1277,13 @@ int mlx4_QUERY_PORT_wrapper(struct mlx4_dev *dev, int slave,
                /* set port type to currently operating port type */
                port_type |= (dev->caps.port_type[vhcr->in_modifier] & 0x3);
 
+#if 0 // AKAROS_PORT
                admin_link_state = priv->mfunc.master.vf_oper[slave].vport[vhcr->in_modifier].state.link_state;
                if (IFLA_VF_LINK_STATE_ENABLE == admin_link_state)
                        port_type |= MLX4_PORT_LINK_UP_MASK;
                else if (IFLA_VF_LINK_STATE_DISABLE == admin_link_state)
                        port_type &= ~MLX4_PORT_LINK_UP_MASK;
+#endif
 
                MLX4_PUT(outbox->buf, port_type,
                         QUERY_PORT_SUPPORTED_TYPE_OFFSET);
@@ -2445,6 +2444,8 @@ enum {
 
 void mlx4_opreq_action(struct work_struct *work)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = container_of(work, struct mlx4_priv,
                                              opreq_task);
        struct mlx4_dev *dev = &priv->dev;
@@ -2539,6 +2540,7 @@ void mlx4_opreq_action(struct work_struct *work)
 
 out:
        mlx4_free_cmd_mailbox(dev, mailbox);
+#endif
 }
 
 static int mlx4_check_smp_firewall_active(struct mlx4_dev *dev,
index f28f051..ceb4e08 100644 (file)
@@ -32,7 +32,7 @@
  * SOFTWARE.
  */
 
-#include <linux/export.h>
+#include <linux_compat.h>
 #include "fw_qos.h"
 #include "fw.h"
 
index a6e7b7c..cada6dd 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/errno.h>
-#include <linux/mm.h>
-#include <linux/scatterlist.h>
-#include <linux/slab.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 
 #include "mlx4.h"
@@ -174,7 +170,11 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                        --cur_order;
 
                if (coherent)
+#if 0 // AKAROS_PORT
                        ret = mlx4_alloc_icm_coherent(&dev->persist->pdev->dev,
+#else
+                       ret = mlx4_alloc_icm_coherent(0,
+#endif
                                                      &chunk->mem[chunk->npages],
                                                      cur_order, gfp_mask);
                else
index f2665a9..6b9725b 100644 (file)
 #ifndef MLX4_ICM_H
 #define MLX4_ICM_H
 
-#include <linux/list.h>
-#include <linux/pci.h>
-#include <linux/mutex.h>
-
 #define MLX4_ICM_CHUNK_LEN                                             \
        ((256 - sizeof (struct list_head) - 2 * sizeof (int)) /         \
         (sizeof (struct scatterlist)))
index addf0f1..2806444 100644 (file)
@@ -31,8 +31,6 @@
  * SOFTWARE.
  */
 
-#include <linux/slab.h>
-#include <linux/export.h>
 #include <linux/errno.h>
 
 #include "mlx4.h"
@@ -44,8 +42,8 @@ struct mlx4_device_context {
        void                   *context;
 };
 
-static LIST_HEAD(intf_list);
-static LIST_HEAD(dev_list);
+static LINUX_LIST_HEAD(intf_list);
+static LINUX_LIST_HEAD(dev_list);
 static DEFINE_MUTEX(intf_mutex);
 
 static void mlx4_add_device(struct mlx4_interface *intf, struct mlx4_priv *priv)
@@ -123,7 +121,7 @@ int mlx4_do_bond(struct mlx4_dev *dev, bool enable)
        struct mlx4_device_context *dev_ctx = NULL, *temp_dev_ctx;
        unsigned long flags;
        int ret;
-       LIST_HEAD(bond_list);
+       LINUX_LIST_HEAD(bond_list);
 
        if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_PORT_REMAP))
                return -ENOTSUPP;
index 25c63f8..0f450f9 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/errno.h>
-#include <linux/pci.h>
-#include <linux/dma-mapping.h>
-#include <linux/slab.h>
-#include <linux/io-mapping.h>
-#include <linux/delay.h>
-#include <linux/kmod.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/doorbell.h>
 
@@ -150,7 +141,7 @@ static bool use_prio;
 module_param_named(use_prio, use_prio, bool, 0444);
 MODULE_PARM_DESC(use_prio, "Enable steering by VLAN priority on ETH ports (deprecated)");
 
-int log_mtts_per_seg = LOG2_UP(MLX4_MTT_ENTRY_PER_SEG);
+int log_mtts_per_seg = ilog2(MLX4_MTT_ENTRY_PER_SEG);
 module_param_named(log_mtts_per_seg, log_mtts_per_seg, int, 0444);
 MODULE_PARM_DESC(log_mtts_per_seg, "Log2 number of MTT entries per segment (1-7)");
 
@@ -397,7 +388,7 @@ static int mlx4_dev_cap(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
        dev->caps.mtt_entry_sz       = dev_cap->mtt_entry_sz;
 
        dev->caps.max_msg_sz         = dev_cap->max_msg_sz;
-       dev->caps.page_size_cap      = ~(u32) (dev_cap->min_page_sz - 1);
+       dev->caps.page_size_cap      = ~(uint32_t) (dev_cap->min_page_sz - 1);
        dev->caps.flags              = dev_cap->flags;
        dev->caps.flags2             = dev_cap->flags2;
        dev->caps.bmme_flags         = dev_cap->bmme_flags;
@@ -962,10 +953,12 @@ static void mlx4_request_modules(struct mlx4_dev *dev)
                        has_eth_port = true;
        }
 
+#if 0 // AKAROS_PORT
        if (has_eth_port)
                request_module_nowait(EN_DRV_NAME);
        if (has_ib_port || (dev->caps.flags & MLX4_DEV_CAP_FLAG_IBOE))
                request_module_nowait(IB_DRV_NAME);
+#endif
 }
 
 /*
@@ -1159,6 +1152,8 @@ static ssize_t set_port_ib_mtu(struct device *dev,
                             struct device_attribute *attr,
                             const char *buf, size_t count)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_port_info *info = container_of(attr, struct mlx4_port_info,
                                                   port_mtu_attr);
        struct mlx4_dev *mdev = info->dev;
@@ -1198,6 +1193,7 @@ err_set_port:
        qunlock(&priv->port_mutex);
        mlx4_start_sense(mdev);
        return err ? err : count;
+#endif
 }
 
 int mlx4_bond(struct mlx4_dev *dev)
@@ -1619,6 +1615,8 @@ static void mlx4_slave_exit(struct mlx4_dev *dev)
 
 static int map_bf_area(struct mlx4_dev *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        resource_size_t bf_start;
        resource_size_t bf_len;
@@ -1636,12 +1634,16 @@ static int map_bf_area(struct mlx4_dev *dev)
                err = -ENOMEM;
 
        return err;
+#endif
 }
 
 static void unmap_bf_area(struct mlx4_dev *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        if (mlx4_priv(dev)->bf_mapping)
                io_mapping_free(mlx4_priv(dev)->bf_mapping);
+#endif
 }
 
 uint64_t mlx4_read_clock(struct mlx4_dev *dev)
@@ -1711,6 +1713,8 @@ static void mlx4_close_fw(struct mlx4_dev *dev)
 
 static int mlx4_comm_check_offline(struct mlx4_dev *dev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
 #define COMM_CHAN_OFFLINE_OFFSET 0x09
 
        uint32_t comm_flags;
@@ -1735,6 +1739,7 @@ static int mlx4_comm_check_offline(struct mlx4_dev *dev)
        }
        mlx4_err(dev, "Communication channel is offline.\n");
        return -EIO;
+#endif
 }
 
 static void mlx4_reset_vf_support(struct mlx4_dev *dev)
@@ -2146,8 +2151,10 @@ static int mlx4_init_hca(struct mlx4_dev *dev)
                }
        }
 
+#if 0 // AKAROS_PORT
        if (map_bf_area(dev))
                mlx4_dbg(dev, "Failed to map blue flame area\n");
+#endif
 
        /*Only the master set the ports, all the rest got it from it.*/
        if (!mlx4_is_slave(dev))
@@ -2490,6 +2497,7 @@ err_uar_table_free:
 
 static void mlx4_enable_msi_x(struct mlx4_dev *dev)
 {
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct msix_entry *entries;
        int i;
@@ -2537,6 +2545,7 @@ no_msi:
 
        for (i = 0; i < 2; ++i)
                priv->eq_table.eq[i].irq = dev->persist->pdev->irq;
+#endif
 }
 
 static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
@@ -2554,6 +2563,7 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
        }
 
        sprintf(info->dev_name, "mlx4_port%d", port);
+#if 0 // AKAROS_PORT
        info->port_attr.attr.name = info->dev_name;
        if (mlx4_is_mfunc(dev))
                info->port_attr.attr.mode = S_IRUGO;
@@ -2569,8 +2579,10 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
                mlx4_err(dev, "Failed to create file for port %d\n", port);
                info->port = -1;
        }
+#endif
 
        sprintf(info->dev_mtu_name, "mlx4_port%d_mtu", port);
+#if 0 // AKAROS_PORT
        info->port_mtu_attr.attr.name = info->dev_mtu_name;
        if (mlx4_is_mfunc(dev))
                info->port_mtu_attr.attr.mode = S_IRUGO;
@@ -2589,18 +2601,22 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
                                   &info->port_attr);
                info->port = -1;
        }
+#endif
 
        return err;
 }
 
 static void mlx4_cleanup_port_info(struct mlx4_port_info *info)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        if (info->port < 0)
                return;
 
        device_remove_file(&info->dev->persist->pdev->dev, &info->port_attr);
        device_remove_file(&info->dev->persist->pdev->dev,
                           &info->port_mtu_attr);
+#endif
 }
 
 static int mlx4_init_steering(struct mlx4_dev *dev)
@@ -2655,10 +2671,12 @@ static void mlx4_clear_steering(struct mlx4_dev *dev)
        kfree(priv->steer);
 }
 
+#if 0 // AKAROS_PORT
 static int extended_func_num(struct pci_device *pdev)
 {
        return PCI_SLOT(pdev->devfn) * 8 + PCI_FUNC(pdev->devfn);
 }
+#endif
 
 #define MLX4_OWNER_BASE        0x8069c
 #define MLX4_OWNER_SIZE        4
@@ -2711,6 +2729,8 @@ static uint64_t mlx4_enable_sriov(struct mlx4_dev *dev,
                                  uint8_t total_vfs, int existing_vfs,
                                  int reset_flow)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        uint64_t dev_flags = dev->flags;
        int err = 0;
 
@@ -2761,6 +2781,7 @@ free_mem:
        dev->persist->num_vfs = 0;
        kfree(dev->dev_vfs);
        return dev_flags & ~MLX4_FLAG_MASTER;
+#endif
 }
 
 enum {
@@ -2807,7 +2828,9 @@ static int mlx4_load_one(struct pci_device *pdev, int pci_dev_data,
        INIT_LIST_HEAD(&priv->bf_list);
        qlock_init(&priv->bf_mutex);
 
+#if 0 // AKAROS_PORT
        dev->rev_id = pdev->revision;
+#endif
        dev->numa_node = dev_to_node(&pdev->dev);
 
        /* Detect if this device is a virtual function */
@@ -2842,6 +2865,7 @@ static int mlx4_load_one(struct pci_device *pdev, int pci_dev_data,
                        goto err_sriov;
                }
 
+#if 0 // AKAROS_PORT
                if (total_vfs) {
                        dev->flags = MLX4_FLAG_MASTER;
                        existing_vfs = pci_num_vf(pdev);
@@ -2849,6 +2873,7 @@ static int mlx4_load_one(struct pci_device *pdev, int pci_dev_data,
                                dev->flags |= MLX4_FLAG_SRIOV;
                        dev->persist->num_vfs = total_vfs;
                }
+#endif
        }
 
        /* on load remove any previous indication of internal error,
@@ -2948,6 +2973,7 @@ slave_start:
                         * Running in slave mode */
                        mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_ALL);
                        /* We're not a PF */
+#if 0 // AKAROS_PORT
                        if (dev->flags & MLX4_FLAG_SRIOV) {
                                if (!existing_vfs)
                                        pci_disable_sriov(pdev);
@@ -2955,6 +2981,7 @@ slave_start:
                                        atomic_dec(&pf_loading);
                                dev->flags &= ~MLX4_FLAG_SRIOV;
                        }
+#endif
                        if (!mlx4_is_slave(dev))
                                mlx4_free_ownership(dev);
                        dev->flags |= MLX4_FLAG_SLAVE;
@@ -3065,6 +3092,7 @@ slave_start:
        }
 
        err = mlx4_setup_hca(dev);
+#if 0 // AKAROS_PORT
        if (err == -EBUSY && (dev->flags & MLX4_FLAG_MSI_X) &&
            !mlx4_is_mfunc(dev)) {
                dev->flags &= ~MLX4_FLAG_MSI_X;
@@ -3073,6 +3101,7 @@ slave_start:
                pci_disable_msix(pdev);
                err = mlx4_setup_hca(dev);
        }
+#endif
 
        if (err)
                goto err_steer;
@@ -3137,8 +3166,10 @@ err_steer:
                mlx4_clear_steering(dev);
 
 err_disable_msix:
+#if 0 // AKAROS_PORT
        if (dev->flags & MLX4_FLAG_MSI_X)
                pci_disable_msix(pdev);
+#endif
 
 err_free_eq:
        mlx4_free_eq_table(dev);
@@ -3171,10 +3202,12 @@ err_cmd:
        mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_ALL);
 
 err_sriov:
+#if 0 // AKAROS_PORT
        if (dev->flags & MLX4_FLAG_SRIOV && !existing_vfs) {
                pci_disable_sriov(pdev);
                dev->flags &= ~MLX4_FLAG_SRIOV;
        }
+#endif
 
        if (mlx4_is_master(dev) && dev->persist->num_vfs && !reset_flow)
                atomic_dec(&pf_loading);
@@ -3250,13 +3283,25 @@ static int __mlx4_init_one(struct pci_device *pdev, int pci_dev_data,
 
        /* Check for BARs. */
        if (!(pci_dev_data & MLX4_PCI_DEV_IS_VF) &&
+#if 0 // AKAROS_PORT
            !(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
+#else
+           !pci_get_membar(pdev, 0)) {
+#endif
                dev_err(&pdev->dev, "Missing DCS, aborting (driver_data: 0x%x, pci_resource_flags(pdev, 0):0x%lx)\n",
+#if 0 // AKAROS_PORT
                        pci_dev_data, pci_resource_flags(pdev, 0));
+#else
+                       pci_dev_data, pci_get_membar(pdev, 0));
+#endif
                err = -ENODEV;
                goto err_disable_pdev;
        }
+#if 0 // AKAROS_PORT
        if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
+#else
+       if (!pci_get_membar(pdev, 2)) {
+#endif
                dev_err(&pdev->dev, "Missing UAR, aborting\n");
                err = -ENODEV;
                goto err_disable_pdev;
@@ -3291,6 +3336,7 @@ static int __mlx4_init_one(struct pci_device *pdev, int pci_dev_data,
 
        /* Allow large DMA segments, up to the firmware limit of 1 GB */
        dma_set_max_seg_size(&pdev->dev, 1024 * 1024 * 1024);
+#if 0 // AKAROS_PORT
        /* Detect if this device is a virtual function */
        if (pci_dev_data & MLX4_PCI_DEV_IS_VF) {
                /* When acting as pf, we normally skip vfs unless explicitly
@@ -3316,6 +3362,7 @@ static int __mlx4_init_one(struct pci_device *pdev, int pci_dev_data,
                        }
                }
        }
+#endif
 
        err = mlx4_catas_init(&priv->dev);
        if (err)
@@ -3331,7 +3378,9 @@ err_catas:
        mlx4_catas_end(&priv->dev);
 
 err_release_regions:
+#if 0 // AKAROS_PORT
        pci_release_regions(pdev);
+#endif
 
 err_disable_pdev:
        pci_disable_device(pdev);
@@ -3448,8 +3497,10 @@ static void mlx4_unload_one(struct pci_device *pdev)
                mlx4_multi_func_cleanup(dev);
        mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_ALL);
 
+#if 0 // AKAROS_PORT
        if (dev->flags & MLX4_FLAG_MSI_X)
                pci_disable_msix(pdev);
+#endif
 
        if (!mlx4_is_slave(dev))
                mlx4_free_ownership(dev);
@@ -3494,12 +3545,14 @@ static void mlx4_remove_one(struct pci_device *pdev)
        else
                mlx4_info(dev, "%s: interface is down\n", __func__);
        mlx4_catas_end(dev);
+#if 0 // AKAROS_PORT
        if (dev->flags & MLX4_FLAG_SRIOV && !active_vfs) {
                mlx4_warn(dev, "Disabling SR-IOV\n");
                pci_disable_sriov(pdev);
        }
 
        pci_release_regions(pdev);
+#endif
        pci_disable_device(pdev);
        kfree(dev->persist);
        kfree(priv);
@@ -3624,6 +3677,8 @@ static pci_ers_result_t mlx4_pci_err_detected(struct pci_device *pdev,
 
 static pci_ers_result_t mlx4_pci_slot_reset(struct pci_device *pdev)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
        struct mlx4_dev  *dev  = persist->dev;
        struct mlx4_priv *priv = mlx4_priv(dev);
@@ -3665,6 +3720,7 @@ end:
        qunlock(&persist->interface_state_mutex);
 
        return ret ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
+#endif
 }
 
 static void mlx4_shutdown(struct pci_device *pdev)
@@ -3678,6 +3734,7 @@ static void mlx4_shutdown(struct pci_device *pdev)
        qunlock(&persist->interface_state_mutex);
 }
 
+#if 0 // AKAROS_PORT
 static const struct pci_error_handlers mlx4_err_handler = {
        .error_detected = mlx4_pci_err_detected,
        .slot_reset     = mlx4_pci_slot_reset,
@@ -3691,6 +3748,7 @@ static struct pci_driver mlx4_driver = {
        .remove         = mlx4_remove_one,
        .err_handler    = &mlx4_err_handler,
 };
+#endif
 
 static int __init mlx4_verify_params(void)
 {
@@ -3739,17 +3797,21 @@ static int __init mlx4_init(void)
        if (mlx4_verify_params())
                return -EINVAL;
 
-
        mlx4_wq = create_singlethread_workqueue("mlx4");
        if (!mlx4_wq)
                return -ENOMEM;
 
+#if 0 // AKAROS_PORT
        ret = pci_register_driver(&mlx4_driver);
        if (ret < 0)
                destroy_workqueue(mlx4_wq);
        return ret < 0 ? ret : 0;
+#else
+       return 0;
+#endif
 }
 
+#if 0 // AKAROS_PORT
 static void __exit mlx4_cleanup(void)
 {
        pci_unregister_driver(&mlx4_driver);
@@ -3758,3 +3820,4 @@ static void __exit mlx4_cleanup(void)
 
 module_init(mlx4_init);
 module_exit(mlx4_cleanup);
+#endif
index 30cc5d6..47a3741 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/string.h>
-#include <linux/etherdevice.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
-#include <linux/export.h>
-
 #include "mlx4.h"
 
 static const uint8_t zero_gid[16];     /* automatically initialized to 0 */
index ef69b98..6c34d04 100644 (file)
 #ifndef MLX4_H
 #define MLX4_H
 
-#include <linux/mutex.h>
-#include <linux/radix-tree.h>
-#include <linux/rbtree.h>
-#include <linux/timer.h>
-#include <linux/semaphore.h>
-#include <linux/workqueue.h>
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/driver.h>
 #include <linux/mlx4/doorbell.h>
index 130a407..ede278a 100644 (file)
 #ifndef _MLX4_EN_H_
 #define _MLX4_EN_H_
 
-#include <linux/bitops.h>
-#include <linux/compiler.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/netdevice.h>
-#include <linux/if_vlan.h>
-#include <linux/net_tstamp.h>
-#ifdef CONFIG_MLX4_EN_DCB
-#include <linux/dcbnl.h>
-#endif
-#include <linux/cpu_rmap.h>
-#include <linux/ptp_clock_kernel.h>
-
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/qp.h>
 #include <linux/mlx4/cq.h>
@@ -214,7 +201,7 @@ enum cq_type {
 
 
 struct mlx4_en_tx_info {
-       struct sk_buff *skb;
+       struct block *block;
        dma_addr_t      map0_dma;
        uint32_t                map0_byte_count;
        uint32_t                nr_txbb;
@@ -402,6 +389,7 @@ struct mlx4_en_dev {
        uint32_t                     priv_pdn;
        spinlock_t              uar_lock;
        uint8_t                 mac_removed[MLX4_MAX_PORTS + 1];
+#if 0 // AKAROS_PORT
        rwlock_t                clock_lock;
        uint32_t                        nominal_c_mult;
        struct cyclecounter     cycles;
@@ -411,6 +399,7 @@ struct mlx4_en_dev {
        struct ptp_clock        *ptp_clock;
        struct ptp_clock_info   ptp_clock_info;
        struct notifier_block   nb;
+#endif
 };
 
 
@@ -463,11 +452,13 @@ struct mlx4_en_frag_info {
 
 #endif
 
+#if 0 // AKAROS_PORT
 struct ethtool_flow_id {
        struct list_head list;
        struct ethtool_rx_flow_spec flow_spec;
        uint64_t id;
 };
+#endif
 
 enum {
        MLX4_EN_FLAG_PROMISC            = (1 << 0),
@@ -500,9 +491,11 @@ struct mlx4_en_priv {
        struct net_device_stats ret_stats;
        struct mlx4_en_port_state port_state;
        spinlock_t stats_lock;
+#if 0 // AKAROS_PORT
        struct ethtool_flow_id ethtool_rules[MAX_NUM_OF_FS_RULES];
        /* To allow rules removal while port is going down */
        struct list_head ethtool_list;
+#endif
 
        unsigned long last_moder_packets[MAX_RX_RINGS];
        unsigned long last_moder_tx_packets;
@@ -578,7 +571,9 @@ struct mlx4_en_priv {
        struct mlx4_en_stat_out_mbox hw_stats;
        int vids[128];
        bool wol;
+#if 0 // AKAROS_PORT
        struct device *ddev;
+#endif
        int base_tx_qpn;
        struct hlist_head mac_hash[MLX4_EN_MAC_HASH_SIZE];
        struct hwtstamp_config hwtstamp_config;
@@ -611,7 +606,9 @@ struct mlx4_mac_entry {
        struct hlist_node hlist;
        unsigned char mac[Eaddrlen + 2];
        uint64_t reg_id;
+#if 0 // AKAROS_PORT
        struct rcu_head rcu;
+#endif
 };
 
 static inline struct mlx4_cqe *mlx4_en_get_cqe(void *buf, int idx, int cqe_sz)
@@ -830,7 +827,7 @@ void mlx4_en_ex_selftest(struct ether *dev, uint32_t *flags,
 void mlx4_en_ptp_overflow_check(struct mlx4_en_dev *mdev);
 
 #define DEV_FEATURE_CHANGED(dev, new_features, feature) \
-       ((dev->features & feature) ^ (new_features & feature))
+       ((dev->feat & feature) ^ (new_features & feature))
 
 int mlx4_en_reset_config(struct ether *dev,
                         struct hwtstamp_config ts_config,
@@ -852,10 +849,11 @@ void mlx4_en_fill_hwtstamps(struct mlx4_en_dev *mdev,
 void mlx4_en_init_timestamp(struct mlx4_en_dev *mdev);
 void mlx4_en_remove_timestamp(struct mlx4_en_dev *mdev);
 
+#if 0 // AKAROS_PORT
 /* Globals
  */
 extern const struct ethtool_ops mlx4_en_ethtool_ops;
-
+#endif
 
 
 /*
@@ -866,11 +864,18 @@ __printf(3, 4)
 void en_print(const char *level, const struct mlx4_en_priv *priv,
              const char *format, ...);
 
+#if 0 // AKAROS_PORT
 #define en_dbg(mlevel, priv, format, ...)                              \
 do {                                                                   \
        if (NETIF_MSG_##mlevel & (priv)->msg_enable)                    \
                en_print(KERN_DEBUG, priv, format, ##__VA_ARGS__);      \
 } while (0)
+#else
+#define en_dbg(mlevel, priv, format, ...)                              \
+do {                                                                   \
+               en_print(KERN_DEBUG, priv, format, ##__VA_ARGS__);      \
+} while (0)
+#endif
 #define en_warn(priv, format, ...)                                     \
        en_print(KERN_WARNING, priv, format, ##__VA_ARGS__)
 #define en_err(priv, format, ...)                                      \
index fbaf49b..927cf70 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/errno.h>
-#include <linux/export.h>
-#include <linux/slab.h>
-#include <linux/kernel.h>
-#include <linux/vmalloc.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 
 #include "mlx4.h"
@@ -117,11 +112,13 @@ static int mlx4_buddy_init(struct mlx4_buddy *buddy, int max_order)
                s = BITS_TO_LONGS(1 << (buddy->max_order - i));
                buddy->bits[i] = kzmalloc((s) * (sizeof(long)),
                                          KMALLOC_WAIT | __GFP_NOWARN);
+#if 0 // AKAROS_PORT
                if (!buddy->bits[i]) {
                        buddy->bits[i] = vzalloc(s * sizeof(long));
                        if (!buddy->bits[i])
                                goto err_out_free;
                }
+#endif
        }
 
        set_bit(0, buddy->bits[buddy->max_order]);
@@ -129,9 +126,11 @@ static int mlx4_buddy_init(struct mlx4_buddy *buddy, int max_order)
 
        return 0;
 
+#if 0 // AKAROS_PORT
 err_out_free:
        for (i = 0; i <= buddy->max_order; ++i)
                kvfree(buddy->bits[i]);
+#endif
 
 err_out:
        kfree(buddy->bits);
@@ -142,6 +141,8 @@ err_out:
 
 static void mlx4_buddy_cleanup(struct mlx4_buddy *buddy)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        int i;
 
        for (i = 0; i <= buddy->max_order; ++i)
@@ -149,6 +150,7 @@ static void mlx4_buddy_cleanup(struct mlx4_buddy *buddy)
 
        kfree(buddy->bits);
        kfree(buddy->num_free);
+#endif
 }
 
 uint32_t __mlx4_alloc_mtt_range(struct mlx4_dev *dev, int order)
@@ -298,6 +300,8 @@ static int mlx4_HW2SW_MPT(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox
 int mlx4_mr_hw_get_mpt(struct mlx4_dev *dev, struct mlx4_mr *mmr,
                       struct mlx4_mpt_entry ***mpt_entry)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        int err;
        int key = key_to_hw_index(mmr->key) & (dev->caps.num_mpts - 1);
        struct mlx4_cmd_mailbox *mailbox = NULL;
@@ -343,6 +347,7 @@ int mlx4_mr_hw_get_mpt(struct mlx4_dev *dev, struct mlx4_mr *mmr,
 free_mailbox:
        mlx4_free_cmd_mailbox(dev, mailbox);
        return err;
+#endif
 }
 EXPORT_SYMBOL_GPL(mlx4_mr_hw_get_mpt);
 
index a9d53e0..c2580b6 100644 (file)
  */
 
 #include <linux/errno.h>
-#include <linux/export.h>
-#include <linux/io-mapping.h>
-
-#include <asm/page.h>
-
 #include "mlx4.h"
 #include "icm.h"
 
@@ -156,7 +151,11 @@ int mlx4_uar_alloc(struct mlx4_dev *dev, struct mlx4_uar *uar)
                                       dev->caps.uar_page_size);
        else
                offset = uar->index;
+#if 0 // AKAROS_PORT
        uar->pfn = (pci_resource_start(dev->persist->pdev, 2) >> PAGE_SHIFT)
+#else
+       uar->pfn = ((uintptr_t)pci_resource_start(dev->persist->pdev, 2) >> PAGE_SHIFT)
+#endif
                    + offset;
        uar->map = NULL;
        return 0;
@@ -171,6 +170,8 @@ EXPORT_SYMBOL_GPL(mlx4_uar_free);
 
 int mlx4_bf_alloc(struct mlx4_dev *dev, struct mlx4_bf *bf, int node)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        struct mlx4_uar *uar;
        int err = 0;
@@ -238,11 +239,14 @@ free_kmalloc:
 out:
        qunlock(&priv->bf_mutex);
        return err;
+#endif
 }
 EXPORT_SYMBOL_GPL(mlx4_bf_alloc);
 
 void mlx4_bf_free(struct mlx4_dev *dev, struct mlx4_bf *bf)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        int idx;
 
@@ -264,6 +268,7 @@ void mlx4_bf_free(struct mlx4_dev *dev, struct mlx4_bf *bf)
                list_add(&bf->uar->bf_list, &priv->bf_list);
 
        qunlock(&priv->bf_mutex);
+#endif
 }
 EXPORT_SYMBOL_GPL(mlx4_bf_free);
 
index 346cf9b..05e43c5 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/errno.h>
-#include <linux/if_ether.h>
-#include <linux/if_vlan.h>
-#include <linux/export.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 
 #include "mlx4.h"
index 01b774f..2e76ab4 100644 (file)
@@ -32,8 +32,6 @@
  * SOFTWARE.
  */
 
-#include <linux/slab.h>
-
 #include "mlx4.h"
 #include "fw.h"
 
@@ -83,7 +81,9 @@ uint64_t mlx4_make_profile(struct mlx4_dev *dev,
        uint64_t total_size = 0;
        struct mlx4_resource *profile;
        struct mlx4_resource tmp;
+#if 0 // AKAROS_PORT
        struct sysinfo si;
+#endif
        int i, j;
 
        profile = kzmalloc((MLX4_RES_NUM) * (sizeof(*profile)), KMALLOC_WAIT);
@@ -102,9 +102,14 @@ uint64_t mlx4_make_profile(struct mlx4_dev *dev,
         * That limits us to 8TB of memory registration per HCA with
         * 4KB pages, which is probably OK for the next few months.
         */
+#if 0 // AKAROS_PORT
        si_meminfo(&si);
        request->num_mtt =
                ROUNDUPPWR2(MAX_T(unsigned, request->num_mtt, MIN(1UL << (31 - log_mtts_per_seg), si.totalram >> (log_mtts_per_seg - 1))));
+#else
+       request->num_mtt =
+               ROUNDUPPWR2(MAX_T(unsigned, request->num_mtt, 1UL << (31 - log_mtts_per_seg)));
+#endif
 
        profile[MLX4_RES_QP].size     = dev_cap->qpc_entry_sz;
        profile[MLX4_RES_RDMARC].size = dev_cap->rdmarc_entry_sz;
index 80bc69c..652e032 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/gfp.h>
-#include <linux/export.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 #include <linux/mlx4/qp.h>
-
 #include "mlx4.h"
 #include "icm.h"
 
@@ -249,6 +246,8 @@ int mlx4_qp_reserve_range(struct mlx4_dev *dev, int cnt, int align,
        flags &= dev->caps.alloc_res_qp_mask;
 
        if (mlx4_is_mfunc(dev)) {
+               panic("Disabled");
+#if 0 // AKAROS_PORT
                set_param_l(&in_param,
                            (((uint32_t)flags) << 24) | (uint32_t)cnt);
                set_param_h(&in_param, align);
@@ -261,6 +260,7 @@ int mlx4_qp_reserve_range(struct mlx4_dev *dev, int cnt, int align,
 
                *base = get_param_l(&out_param);
                return 0;
+#endif
        }
        return __mlx4_qp_reserve_range(dev, cnt, align, base, flags);
 }
index ebd3125..ebb5d23 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/errno.h>
-#include <linux/pci.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/jiffies.h>
-
+#include <linux_compat.h>
 #include "mlx4.h"
 
 int mlx4_reset(struct mlx4_dev *dev)
@@ -99,14 +94,22 @@ int mlx4_reset(struct mlx4_dev *dev)
        }
 
        /* grab HW semaphore to lock out flash updates */
+#if 0 // AKAROS_PORT
        end = jiffies + MLX4_SEM_TIMEOUT_JIFFIES;
+#else
+       end = MLX4_SEM_TIMEOUT_JIFFIES;
+#endif
        do {
                sem = read32(reset + MLX4_SEM_OFFSET);
                if (!sem)
                        break;
 
                kthread_usleep(1000 * 1);
+#if 0 // AKAROS_PORT
        } while (time_before(jiffies, end));
+#else
+       } while (--end);
+#endif
 
        if (sem) {
                mlx4_err(dev, "Failed to obtain HW semaphore, aborting\n");
@@ -122,14 +125,22 @@ int mlx4_reset(struct mlx4_dev *dev)
        /* Docs say to wait one second before accessing device */
        kthread_usleep(1000 * 1000);
 
+#if 0 // AKAROS_PORT
        end = jiffies + MLX4_RESET_TIMEOUT_JIFFIES;
+#else
+       end = MLX4_RESET_TIMEOUT_JIFFIES;
+#endif
        do {
                if (!pci_read_config_word(dev->persist->pdev, PCI_VENDOR_ID,
                                          &vendor) && vendor != 0xffff)
                        break;
 
                kthread_usleep(1000 * 1);
+#if 0 // AKAROS_PORT
        } while (time_before(jiffies, end));
+#else
+       } while (--end);
+#endif
 
        if (vendor == 0xffff) {
                err = -ENODEV;
@@ -137,6 +148,7 @@ int mlx4_reset(struct mlx4_dev *dev)
                goto out;
        }
 
+#if 0 // AKAROS_PORT
        /* Now restore the PCI headers */
        if (pcie_cap) {
                devctl = hca_header[(pcie_cap + PCI_EXP_DEVCTL) / 4];
@@ -156,6 +168,7 @@ int mlx4_reset(struct mlx4_dev *dev)
                        goto out;
                }
        }
+#endif
 
        for (i = 0; i < 16; ++i) {
                if (i * 4 == PCI_COMMAND)
index 34d7ff4..20c9384 100644 (file)
  * SOFTWARE.
  */
 
-#include <linux/sched.h>
-#include <linux/pci.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/io.h>
-#include <linux/slab.h>
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 #include <linux/mlx4/qp.h>
-#include <linux/if_ether.h>
-#include <linux/etherdevice.h>
 
 #include "mlx4.h"
 #include "fw.h"
@@ -241,6 +234,8 @@ static void *res_tracker_lookup(struct rb_root *root, uint64_t res_id)
 
 static int res_tracker_insert(struct rb_root *root, struct res_common *res)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct rb_node **new = &(root->rb_node), *parent = NULL;
 
        /* Figure out where to put new node */
@@ -262,6 +257,7 @@ static int res_tracker_insert(struct rb_root *root, struct res_common *res)
        rb_insert_color(&res->node, root);
 
        return 0;
+#endif
 }
 
 enum qp_transition {
@@ -701,6 +697,8 @@ static int update_vport_qp_param(struct mlx4_dev *dev,
                                 struct mlx4_cmd_mailbox *inbox,
                                 uint8_t slave, uint32_t qpn)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_qp_context  *qpc = inbox->buf + 8;
        struct mlx4_vport_oper_state *vp_oper;
        struct mlx4_priv *priv;
@@ -770,6 +768,7 @@ static int update_vport_qp_param(struct mlx4_dev *dev,
        }
 out:
        return err;
+#endif
 }
 
 static int mpt_mask(struct mlx4_dev *dev)
@@ -1041,6 +1040,8 @@ static int add_res_range(struct mlx4_dev *dev, int slave, uint64_t base,
                         int count,
                         enum mlx4_resource type, int extra)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        int i;
        int err;
        struct mlx4_priv *priv = mlx4_priv(dev);
@@ -1092,6 +1093,7 @@ undo:
        kfree(res_arr);
 
        return err;
+#endif
 }
 
 static int remove_qp_ok(struct res_qp *res)
@@ -1227,6 +1229,8 @@ static int rem_res_range(struct mlx4_dev *dev, int slave, uint64_t base,
                         int count,
                         enum mlx4_resource type, int extra)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        uint64_t i;
        int err;
        struct mlx4_priv *priv = mlx4_priv(dev);
@@ -1261,6 +1265,7 @@ out:
        spin_unlock_irqsave(mlx4_tlock(dev));
 
        return err;
+#endif
 }
 
 static int qp_res_start_move_to(struct mlx4_dev *dev, int slave, int qpn,
@@ -3951,6 +3956,8 @@ ex_put:
 static int validate_eth_header_mac(int slave, struct _rule_hw *eth_header,
                                   struct list_head *rlist)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mac_res *res, *tmp;
        __be64 be_mac;
 
@@ -3967,6 +3974,7 @@ static int validate_eth_header_mac(int slave, struct _rule_hw *eth_header,
                return -EINVAL;
        }
        return 0;
+#endif
 }
 
 /*
@@ -4252,6 +4260,7 @@ static void detach_qp(struct mlx4_dev *dev, int slave, struct res_qp *rqp)
        }
 }
 
+#if 0 // AKAROS_PORT
 static int _move_all_busy(struct mlx4_dev *dev, int slave,
                          enum mlx4_resource type, int print)
 {
@@ -4391,7 +4400,7 @@ static void rem_slave_srqs(struct mlx4_dev *dev, int slave)
        struct res_srq *tmp;
        int state;
        uint64_t in_param;
-       LIST_HEAD(tlist);
+       LINUX_LIST_HEAD(tlist);
        int srqn;
        int err;
 
@@ -4457,7 +4466,7 @@ static void rem_slave_cqs(struct mlx4_dev *dev, int slave)
        struct res_cq *tmp;
        int state;
        uint64_t in_param;
-       LIST_HEAD(tlist);
+       LINUX_LIST_HEAD(tlist);
        int cqn;
        int err;
 
@@ -4520,7 +4529,7 @@ static void rem_slave_mrs(struct mlx4_dev *dev, int slave)
        struct res_mpt *tmp;
        int state;
        uint64_t in_param;
-       LIST_HEAD(tlist);
+       LINUX_LIST_HEAD(tlist);
        int mptn;
        int err;
 
@@ -4588,7 +4597,7 @@ static void rem_slave_mtts(struct mlx4_dev *dev, int slave)
        struct res_mtt *mtt;
        struct res_mtt *tmp;
        int state;
-       LIST_HEAD(tlist);
+       LINUX_LIST_HEAD(tlist);
        int base;
        int err;
 
@@ -4691,7 +4700,7 @@ static void rem_slave_eqs(struct mlx4_dev *dev, int slave)
        struct res_eq *tmp;
        int err;
        int state;
-       LIST_HEAD(tlist);
+       LINUX_LIST_HEAD(tlist);
        int eqn;
 
        err = move_all_busy(dev, slave, RES_EQ);
@@ -4798,9 +4807,12 @@ static void rem_slave_xrcdns(struct mlx4_dev *dev, int slave)
        }
        spin_unlock_irqsave(mlx4_tlock(dev));
 }
+#endif
 
 void mlx4_delete_all_resources_for_slave(struct mlx4_dev *dev, int slave)
 {
+       panic("Disabled");
+#if 0 // AKAROS_PORT
        struct mlx4_priv *priv = mlx4_priv(dev);
        mlx4_reset_roce_gids(dev, slave);
        qlock(&priv->mfunc.master.res_tracker.slave_list[slave].mutex);
@@ -4816,6 +4828,7 @@ void mlx4_delete_all_resources_for_slave(struct mlx4_dev *dev, int slave)
        rem_slave_counters(dev, slave);
        rem_slave_xrcdns(dev, slave);
        qunlock(&priv->mfunc.master.res_tracker.slave_list[slave].mutex);
+#endif
 }
 
 void mlx4_vf_immed_vlan_work_handler(struct work_struct *_work)
index 8e36819..22a26a4 100644 (file)
@@ -31,9 +31,7 @@
  *
  */
 
-#include <linux/errno.h>
-#include <linux/if_ether.h>
-
+#include <linux_compat.h>
 #include <linux/mlx4/cmd.h>
 
 #include "mlx4.h"
@@ -109,7 +107,11 @@ static void mlx4_sense_port(struct work_struct *work)
 sense_again:
        qunlock(&priv->port_mutex);
        queue_delayed_work(mlx4_wq , &sense->sense_poll,
+#if 0 // AKAROS_PORT
                           round_jiffies_relative(MLX4_SENSE_RANGE));
+#else
+                          MLX4_SENSE_RANGE);
+#endif
 }
 
 void mlx4_start_sense(struct mlx4_dev *dev)
@@ -121,7 +123,11 @@ void mlx4_start_sense(struct mlx4_dev *dev)
                return;
 
        queue_delayed_work(mlx4_wq , &sense->sense_poll,
+#if 0 // AKAROS_PORT
                           round_jiffies_relative(MLX4_SENSE_RANGE));
+#else
+                          MLX4_SENSE_RANGE);
+#endif
 }
 
 void mlx4_stop_sense(struct mlx4_dev *dev)
index 067a67d..784a342 100644 (file)
@@ -34,9 +34,6 @@
 
 #include <linux/mlx4/cmd.h>
 #include <linux/mlx4/srq.h>
-#include <linux/export.h>
-#include <linux/gfp.h>
-
 #include "mlx4.h"
 #include "icm.h"