netif_set_real_num_rx_queues(efx->net_dev, efx->n_rx_channels);
 
        /* Initialise the interrupt moderation settings */
-       efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true);
+       efx_init_irq_moderation(efx, tx_irq_mod_usec, rx_irq_mod_usec, true,
+                               true);
 
        return 0;
 
 }
 
 /* Set interrupt moderation parameters */
-void efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs,
-                            unsigned int rx_usecs, bool rx_adaptive)
+int efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs,
+                           unsigned int rx_usecs, bool rx_adaptive,
+                           bool rx_may_override_tx)
 {
        struct efx_channel *channel;
        unsigned tx_ticks = irq_mod_ticks(tx_usecs, EFX_IRQ_MOD_RESOLUTION);
 
        EFX_ASSERT_RESET_SERIALISED(efx);
 
+       if (tx_ticks > EFX_IRQ_MOD_MAX || rx_ticks > EFX_IRQ_MOD_MAX)
+               return -EINVAL;
+
+       if (tx_ticks != rx_ticks && efx->tx_channel_offset == 0 &&
+           !rx_may_override_tx) {
+               netif_err(efx, drv, efx->net_dev, "Channels are shared. "
+                         "RX and TX IRQ moderation must be equal\n");
+               return -EINVAL;
+       }
+
        efx->irq_rx_adaptive = rx_adaptive;
        efx->irq_rx_moderation = rx_ticks;
        efx_for_each_channel(channel, efx) {
                else if (efx_channel_has_tx_queues(channel))
                        channel->irq_moderation = tx_ticks;
        }
+
+       return 0;
 }
 
 void efx_get_irq_moderation(struct efx_nic *efx, unsigned int *tx_usecs,
 
 
 /* Global */
 extern void efx_schedule_reset(struct efx_nic *efx, enum reset_type type);
-extern void efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs,
-                                   unsigned int rx_usecs, bool rx_adaptive);
+extern int efx_init_irq_moderation(struct efx_nic *efx, unsigned int tx_usecs,
+                                  unsigned int rx_usecs, bool rx_adaptive,
+                                  bool rx_may_override_tx);
 extern void efx_get_irq_moderation(struct efx_nic *efx, unsigned int *tx_usecs,
                                   unsigned int *rx_usecs, bool *rx_adaptive);
 
 
        struct efx_nic *efx = netdev_priv(net_dev);
        struct efx_channel *channel;
        unsigned int tx_usecs, rx_usecs;
-       bool adaptive;
+       bool adaptive, rx_may_override_tx;
+       int rc;
 
        if (coalesce->use_adaptive_tx_coalesce)
                return -EINVAL;
        /* If channels are shared, TX IRQ moderation can be quietly
         * overridden unless it is changed from its old value.
         */
-       if (efx->tx_channel_offset == 0 &&
-           coalesce->tx_coalesce_usecs_irq != tx_usecs &&
-           coalesce->tx_coalesce_usecs_irq != rx_usecs) {
-               netif_err(efx, drv, efx->net_dev, "Channels are shared. "
-                         "RX and TX IRQ moderation must be equal\n");
-               return -EINVAL;
-       }
+       rx_may_override_tx = coalesce->tx_coalesce_usecs_irq == tx_usecs;
        tx_usecs = coalesce->tx_coalesce_usecs_irq;
 
-       efx_init_irq_moderation(efx, tx_usecs, rx_usecs, adaptive);
+       rc = efx_init_irq_moderation(efx, tx_usecs, rx_usecs, adaptive,
+                                    rx_may_override_tx);
+       if (rc != 0)
+               return rc;
+
        efx_for_each_channel(channel, efx)
                efx->type->push_irq_moderation(channel);
 
 
        efx_dword_t timer_cmd;
        struct efx_nic *efx = channel->efx;
 
+       BUILD_BUG_ON(EFX_IRQ_MOD_MAX > (1 << FRF_AB_TC_TIMER_VAL_WIDTH));
+
        /* Set timer register */
        if (channel->irq_moderation) {
                EFX_POPULATE_DWORD_2(timer_cmd,
 
 extern irqreturn_t falcon_legacy_interrupt_a1(int irq, void *dev_id);
 extern void falcon_irq_ack_a1(struct efx_nic *efx);
 
-#define EFX_IRQ_MOD_RESOLUTION 5
+#define EFX_IRQ_MOD_RESOLUTION 5
+#define EFX_IRQ_MOD_MAX                0x1000
 
 /* Global Resources */
 extern int efx_nic_flush_queues(struct efx_nic *efx);
 
 {
        efx_dword_t timer_cmd;
 
+       BUILD_BUG_ON(EFX_IRQ_MOD_MAX > (1 << FRF_CZ_TC_TIMER_VAL_WIDTH));
+
        if (channel->irq_moderation)
                EFX_POPULATE_DWORD_2(timer_cmd,
                                     FRF_CZ_TC_TIMER_MODE,