MLX4_EN_PARM_INT(pfcrx, 0, "Priority based Flow Control policy on RX[7:0]."
                           " Per priority bit mask");
 
+MLX4_EN_PARM_INT(inline_thold, MAX_INLINE,
+                "Threshold for using inline data (range: 17-104, default: 104)");
+
+#define MAX_PFC_TX     0xff
+#define MAX_PFC_RX     0xff
+
 int en_print(const char *level, const struct mlx4_en_priv *priv,
             const char *format, ...)
 {
                params->prof[i].tx_ring_num = params->num_tx_rings_p_up *
                        MLX4_EN_NUM_UP;
                params->prof[i].rss_rings = 0;
+               params->prof[i].inline_thold = inline_thold;
        }
 
        return 0;
        .protocol       = MLX4_PROT_ETH,
 };
 
+void mlx4_en_verify_params(void)
+{
+       if (pfctx > MAX_PFC_TX) {
+               pr_warn("mlx4_en: WARNING: illegal module parameter pfctx 0x%x - should be in range 0-0x%x, will be changed to default (0)\n",
+                       pfctx, MAX_PFC_TX);
+               pfctx = 0;
+       }
+
+       if (pfcrx > MAX_PFC_RX) {
+               pr_warn("mlx4_en: WARNING: illegal module parameter pfcrx 0x%x - should be in range 0-0x%x, will be changed to default (0)\n",
+                       pfcrx, MAX_PFC_RX);
+               pfcrx = 0;
+       }
+
+       if (inline_thold < MIN_PKT_LEN || inline_thold > MAX_INLINE) {
+               pr_warn("mlx4_en: WARNING: illegal module parameter inline_thold %d - should be in range %d-%d, will be changed to default (%d)\n",
+                       inline_thold, MIN_PKT_LEN, MAX_INLINE, MAX_INLINE);
+               inline_thold = MAX_INLINE;
+       }
+}
+
 static int __init mlx4_en_init(void)
 {
+       mlx4_en_verify_params();
+
        return mlx4_register_interface(&mlx4_en_interface);
 }
 
 
 
 #include "mlx4_en.h"
 
-enum {
-       MAX_INLINE = 104, /* 128 - 16 - 4 - 4 */
-       MAX_BF = 256,
-};
-
-static int inline_thold __read_mostly = MAX_INLINE;
-
-module_param_named(inline_thold, inline_thold, int, 0444);
-MODULE_PARM_DESC(inline_thold, "threshold for using inline data");
-
 int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv,
                           struct mlx4_en_tx_ring **pring, int qpn, u32 size,
                           u16 stride, int node, int queue_index)
        ring->size = size;
        ring->size_mask = size - 1;
        ring->stride = stride;
-
-       inline_thold = min(inline_thold, MAX_INLINE);
+       ring->inline_thold = priv->prof->inline_thold;
 
        tmp = size * sizeof(struct mlx4_en_tx_info);
        ring->tx_info = vmalloc_node(tmp, node);
        return ring->buf + index * TXBB_SIZE;
 }
 
-static int is_inline(struct sk_buff *skb, void **pfrag)
+static int is_inline(int inline_thold, struct sk_buff *skb, void **pfrag)
 {
        void *ptr;
 
                }
        } else {
                *lso_header_size = 0;
-               if (!is_inline(skb, NULL))
+               if (!is_inline(priv->prof->inline_thold, skb, NULL))
                        real_size = CTRL_SIZE + (skb_shinfo(skb)->nr_frags + 1) * DS_SIZE;
                else
                        real_size = inline_size(skb);
        tx_info->data_offset = (void *)data - (void *)tx_desc;
 
        tx_info->linear = (lso_header_size < skb_headlen(skb) &&
-                          !is_inline(skb, NULL)) ? 1 : 0;
+                          !is_inline(ring->inline_thold, skb, NULL)) ? 1 : 0;
 
        data += skb_shinfo(skb)->nr_frags + tx_info->linear - 1;
 
-       if (is_inline(skb, &fragptr)) {
+       if (is_inline(ring->inline_thold, skb, &fragptr)) {
                tx_info->inl = 1;
        } else {
                /* Map fragments */