static void enh_desc_init_rx_desc(struct dma_desc *p, int disable_rx_ic,
                                  int mode, int end)
 {
+       p->des01.all_flags = 0;
        p->des01.erx.own = 1;
        p->des01.erx.buffer1_size = BUF_SIZE_8KiB - 1;
 
 
 static void enh_desc_init_tx_desc(struct dma_desc *p, int mode, int end)
 {
-       p->des01.etx.own = 0;
+       p->des01.all_flags = 0;
        if (mode == STMMAC_CHAIN_MODE)
                ehn_desc_tx_set_on_chain(p, end);
        else
 
 static void ndesc_init_rx_desc(struct dma_desc *p, int disable_rx_ic, int mode,
                               int end)
 {
+       p->des01.all_flags = 0;
        p->des01.rx.own = 1;
        p->des01.rx.buffer1_size = BUF_SIZE_2KiB - 1;
 
 
 static void ndesc_init_tx_desc(struct dma_desc *p, int mode, int end)
 {
-       p->des01.tx.own = 0;
+       p->des01.all_flags = 0;
        if (mode == STMMAC_CHAIN_MODE)
                ndesc_tx_set_on_chain(p, end);
        else
 
                goto err_tx_skbuff;
 
        if (priv->extend_desc) {
-               priv->dma_erx = dma_alloc_coherent(priv->device, rxsize *
-                                                  sizeof(struct
-                                                         dma_extended_desc),
-                                                  &priv->dma_rx_phy,
-                                                  GFP_KERNEL);
+               priv->dma_erx = dma_zalloc_coherent(priv->device, rxsize *
+                                                   sizeof(struct
+                                                          dma_extended_desc),
+                                                   &priv->dma_rx_phy,
+                                                   GFP_KERNEL);
                if (!priv->dma_erx)
                        goto err_dma;
 
-               priv->dma_etx = dma_alloc_coherent(priv->device, txsize *
-                                                  sizeof(struct
-                                                         dma_extended_desc),
-                                                  &priv->dma_tx_phy,
-                                                  GFP_KERNEL);
+               priv->dma_etx = dma_zalloc_coherent(priv->device, txsize *
+                                                   sizeof(struct
+                                                          dma_extended_desc),
+                                                   &priv->dma_tx_phy,
+                                                   GFP_KERNEL);
                if (!priv->dma_etx) {
                        dma_free_coherent(priv->device, priv->dma_rx_size *
-                                       sizeof(struct dma_extended_desc),
-                                       priv->dma_erx, priv->dma_rx_phy);
+                                         sizeof(struct dma_extended_desc),
+                                         priv->dma_erx, priv->dma_rx_phy);
                        goto err_dma;
                }
        } else {
-               priv->dma_rx = dma_alloc_coherent(priv->device, rxsize *
-                                                 sizeof(struct dma_desc),
-                                                 &priv->dma_rx_phy,
-                                                 GFP_KERNEL);
+               priv->dma_rx = dma_zalloc_coherent(priv->device, rxsize *
+                                                  sizeof(struct dma_desc),
+                                                  &priv->dma_rx_phy,
+                                                  GFP_KERNEL);
                if (!priv->dma_rx)
                        goto err_dma;
 
-               priv->dma_tx = dma_alloc_coherent(priv->device, txsize *
-                                                 sizeof(struct dma_desc),
-                                                 &priv->dma_tx_phy,
-                                                 GFP_KERNEL);
+               priv->dma_tx = dma_zalloc_coherent(priv->device, txsize *
+                                                  sizeof(struct dma_desc),
+                                                  &priv->dma_tx_phy,
+                                                  GFP_KERNEL);
                if (!priv->dma_tx) {
                        dma_free_coherent(priv->device, priv->dma_rx_size *
-                                       sizeof(struct dma_desc),
-                                       priv->dma_rx, priv->dma_rx_phy);
+                                         sizeof(struct dma_desc),
+                                         priv->dma_rx, priv->dma_rx_phy);
                        goto err_dma;
                }
        }