static int ravb_dmac_init(struct net_device *ndev)
 {
        struct ravb_private *priv = netdev_priv(ndev);
+       const struct ravb_hw_info *info = priv->info;
        int error;
 
        /* Set CONFIG mode */
        ravb_write(ndev, TCCR_TFEN, TCCR);
 
        /* Interrupt init: */
-       if (priv->chip_id == RCAR_GEN3) {
+       if (info->multi_irqs) {
                /* Clear DIL.DPLx */
                ravb_write(ndev, 0, DIL);
                /* Set queue specific interrupt */
 static bool ravb_queue_interrupt(struct net_device *ndev, int q)
 {
        struct ravb_private *priv = netdev_priv(ndev);
+       const struct ravb_hw_info *info = priv->info;
        u32 ris0 = ravb_read(ndev, RIS0);
        u32 ric0 = ravb_read(ndev, RIC0);
        u32 tis  = ravb_read(ndev, TIS);
        if (((ris0 & ric0) & BIT(q)) || ((tis  & tic)  & BIT(q))) {
                if (napi_schedule_prep(&priv->napi[q])) {
                        /* Mask RX and TX interrupts */
-                       if (priv->chip_id == RCAR_GEN2) {
+                       if (!info->multi_irqs) {
                                ravb_write(ndev, ric0 & ~BIT(q), RIC0);
                                ravb_write(ndev, tic & ~BIT(q), TIC);
                        } else {
 {
        struct net_device *ndev = napi->dev;
        struct ravb_private *priv = netdev_priv(ndev);
+       const struct ravb_hw_info *info = priv->info;
        unsigned long flags;
        int q = napi - priv->napi;
        int mask = BIT(q);
 
        /* Re-enable RX/TX interrupts */
        spin_lock_irqsave(&priv->lock, flags);
-       if (priv->chip_id == RCAR_GEN2) {
+       if (!info->multi_irqs) {
                ravb_modify(ndev, RIC0, mask, mask);
                ravb_modify(ndev, TIC,  mask, mask);
        } else {
 static int ravb_open(struct net_device *ndev)
 {
        struct ravb_private *priv = netdev_priv(ndev);
+       const struct ravb_hw_info *info = priv->info;
        struct platform_device *pdev = priv->pdev;
        struct device *dev = &pdev->dev;
        int error;
        napi_enable(&priv->napi[RAVB_BE]);
        napi_enable(&priv->napi[RAVB_NC]);
 
-       if (priv->chip_id == RCAR_GEN2) {
+       if (!info->multi_irqs) {
                error = request_irq(ndev->irq, ravb_interrupt, IRQF_SHARED,
                                    ndev->name, ndev);
                if (error) {
        if (priv->chip_id == RCAR_GEN2)
                ravb_ptp_stop(ndev);
 out_free_irq_nc_tx:
-       if (priv->chip_id == RCAR_GEN2)
+       if (!info->multi_irqs)
                goto out_free_irq;
        free_irq(priv->tx_irqs[RAVB_NC], ndev);
 out_free_irq_nc_rx:
 {
        struct device_node *np = ndev->dev.parent->of_node;
        struct ravb_private *priv = netdev_priv(ndev);
+       const struct ravb_hw_info *info = priv->info;
        struct ravb_tstamp_skb *ts_skb, *ts_skb2;
 
        netif_tx_stop_all_queues(ndev);
                        of_phy_deregister_fixed_link(np);
        }
 
-       if (priv->chip_id != RCAR_GEN2) {
+       if (info->multi_irqs) {
                free_irq(priv->tx_irqs[RAVB_NC], ndev);
                free_irq(priv->rx_irqs[RAVB_NC], ndev);
                free_irq(priv->tx_irqs[RAVB_BE], ndev);
        .max_rx_len = RX_BUF_SZ + RAVB_ALIGN - 1,
        .internal_delay = 1,
        .tx_counters = 1,
+       .multi_irqs = 1,
 };
 
 static const struct ravb_hw_info ravb_gen2_hw_info = {
        pm_runtime_enable(&pdev->dev);
        pm_runtime_get_sync(&pdev->dev);
 
-       if (info->chip_id == RCAR_GEN3)
+       if (info->multi_irqs)
                irq = platform_get_irq_byname(pdev, "ch22");
        else
                irq = platform_get_irq(pdev, 0);
        priv->avb_link_active_low =
                of_property_read_bool(np, "renesas,ether-link-active-low");
 
-       if (info->chip_id == RCAR_GEN3) {
+       if (info->multi_irqs) {
                irq = platform_get_irq_byname(pdev, "ch24");
                if (irq < 0) {
                        error = irq;
 
 {
        struct ravb_private *priv = container_of(ptp, struct ravb_private,
                                                 ptp.info);
+       const struct ravb_hw_info *info = priv->info;
        struct net_device *ndev = priv->ndev;
        unsigned long flags;
 
        priv->ptp.extts[req->index] = on;
 
        spin_lock_irqsave(&priv->lock, flags);
-       if (priv->chip_id == RCAR_GEN2)
+       if (!info->multi_irqs)
                ravb_modify(ndev, GIC, GIC_PTCE, on ? GIC_PTCE : 0);
        else if (on)
                ravb_write(ndev, GIE_PTCS, GIE);
 {
        struct ravb_private *priv = container_of(ptp, struct ravb_private,
                                                 ptp.info);
+       const struct ravb_hw_info *info = priv->info;
        struct net_device *ndev = priv->ndev;
        struct ravb_ptp_perout *perout;
        unsigned long flags;
                error = ravb_ptp_update_compare(priv, (u32)start_ns);
                if (!error) {
                        /* Unmask interrupt */
-                       if (priv->chip_id == RCAR_GEN2)
+                       if (!info->multi_irqs)
                                ravb_modify(ndev, GIC, GIC_PTME, GIC_PTME);
                        else
                                ravb_write(ndev, GIE_PTMS0, GIE);
                perout->period = 0;
 
                /* Mask interrupt */
-               if (priv->chip_id == RCAR_GEN2)
+               if (!info->multi_irqs)
                        ravb_modify(ndev, GIC, GIC_PTME, 0);
                else
                        ravb_write(ndev, GID_PTMD0, GID);