kernel: bump 4.9 to 4.9.111 for 18.06
authorKoen Vandeputte <koen.vandeputte@ncentric.com>
Wed, 11 Jul 2018 12:57:00 +0000 (14:57 +0200)
committerKoen Vandeputte <koen.vandeputte@ncentric.com>
Thu, 12 Jul 2018 11:54:24 +0000 (13:54 +0200)
Refreshed all patches

Compile-tested on: ar71xx
Runtime-tested on: ar71xx

Signed-off-by: Koen Vandeputte <koen.vandeputte@ncentric.com>
include/kernel-version.mk
target/linux/brcm2708/patches-4.9/950-0031-Add-dwc_otg-driver.patch
target/linux/brcm47xx/patches-4.9/830-huawei_e970_support.patch
target/linux/generic/pending-4.9/490-ubi-auto-attach-mtd-device-named-ubi-or-data-on-boot.patch
target/linux/layerscape/patches-4.9/702-pci-support-layerscape.patch
target/linux/sunxi/patches-4.9/0052-stmmac-form-4-12.patch

index 641b652..48c284c 100644 (file)
@@ -4,13 +4,13 @@ LINUX_RELEASE?=1
 
 LINUX_VERSION-3.18 = .71
 LINUX_VERSION-4.4 = .121
-LINUX_VERSION-4.9 = .110
 LINUX_VERSION-4.14 = .52
+LINUX_VERSION-4.9 = .111
 
 LINUX_KERNEL_HASH-3.18.71 = 5abc9778ad44ce02ed6c8ab52ece8a21c6d20d21f6ed8a19287b4a38a50c1240
 LINUX_KERNEL_HASH-4.4.121 = 44a88268b5088dc326b30c9b9133ac35a9a200b636b7268d08f32abeae6ca729
-LINUX_KERNEL_HASH-4.9.110 = 379a143a70a79f0eea6c9f6638942b65e6043abdde17ad23264c0abd93c4ea7a
 LINUX_KERNEL_HASH-4.14.52 = a5d226c7b2fd1eb0f01d56e4e2c6a0100784b68df907cc7317f32bde34f88810
+LINUX_KERNEL_HASH-4.9.111 = 5966558959dc580f163766f3fdefd7e57c01b2b45d51202d00b3807c253759dd
 
 remove_uri_prefix=$(subst git://,,$(subst http://,,$(subst https://,,$(1))))
 sanitize_uri=$(call qstrip,$(subst @,_,$(subst :,_,$(subst .,_,$(subst -,_,$(subst /,_,$(1)))))))
index 34e7764..d19027a 100644 (file)
@@ -696,7 +696,7 @@ Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
  }
 --- a/drivers/usb/core/hub.c
 +++ b/drivers/usb/core/hub.c
-@@ -5062,7 +5062,7 @@ static void port_event(struct usb_hub *h
+@@ -5064,7 +5064,7 @@ static void port_event(struct usb_hub *h
        if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
                u16 status = 0, unused;
  
index b6150ed..5d40fe6 100644 (file)
@@ -8,7 +8,7 @@
  #include <asm/bootinfo.h>
  #include <asm/idle.h>
  #include <asm/prom.h>
-@@ -225,6 +226,33 @@ static struct fixed_phy_status bcm47xx_f
+@@ -231,6 +232,33 @@ static struct fixed_phy_status bcm47xx_f
        .duplex = DUPLEX_FULL,
  };
  
@@ -42,7 +42,7 @@
  static int __init bcm47xx_register_bus_complete(void)
  {
        switch (bcm47xx_bus_type) {
-@@ -244,6 +272,7 @@ static int __init bcm47xx_register_bus_c
+@@ -250,6 +278,7 @@ static int __init bcm47xx_register_bus_c
        bcm47xx_workarounds();
  
        fixed_phy_add(PHY_POLL, 0, &bcm47xx_fixed_phy_status, -1);
index 1d44cdb..8b37dba 100644 (file)
@@ -8,7 +8,7 @@ Signed-off-by: Daniel Golle <daniel@makrotopia.org>
 
 --- a/drivers/mtd/ubi/build.c
 +++ b/drivers/mtd/ubi/build.c
-@@ -1223,6 +1223,49 @@ static struct mtd_info * __init open_mtd
+@@ -1226,6 +1226,49 @@ static struct mtd_info * __init open_mtd
        return mtd;
  }
  
@@ -58,7 +58,7 @@ Signed-off-by: Daniel Golle <daniel@makrotopia.org>
  static int __init ubi_init(void)
  {
        int err, i, k;
-@@ -1306,6 +1349,12 @@ static int __init ubi_init(void)
+@@ -1309,6 +1352,12 @@ static int __init ubi_init(void)
                }
        }
  
index 37eb541..724c684 100644 (file)
@@ -2060,7 +2060,7 @@ Signed-off-by: Yangbo Lu <yangbo.lu@nxp.com>
        }
 --- a/drivers/pci/quirks.c
 +++ b/drivers/pci/quirks.c
-@@ -4659,3 +4659,11 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_IN
+@@ -4679,3 +4679,11 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_IN
  DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x2031, quirk_no_aersid);
  DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x2032, quirk_no_aersid);
  DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x2033, quirk_no_aersid);
index a1b0181..1ed1294 100644 (file)
  
        if (priv->hw->mode->set_16kib_bfsize)
                bfsize = priv->hw->mode->set_16kib_bfsize(dev->mtu);
-@@ -1033,235 +1234,409 @@ static int init_dma_desc_rings(struct ne
+@@ -1033,257 +1234,516 @@ static int init_dma_desc_rings(struct ne
  
        priv->dma_buf_sz = bfsize;
  
 -                                               priv->tx_skbuff_dma[i].buf,
 -                                               priv->tx_skbuff_dma[i].len,
 -                                               DMA_TO_DEVICE);
--              }
 +      for (i = 0; i < DMA_TX_SIZE; i++)
 +              stmmac_free_tx_buffer(priv, queue, i);
 +}
--              if (priv->tx_skbuff[i]) {
--                      dev_kfree_skb_any(priv->tx_skbuff[i]);
--                      priv->tx_skbuff[i] = NULL;
--                      priv->tx_skbuff_dma[i].buf = 0;
--                      priv->tx_skbuff_dma[i].map_as_page = false;
--              }
++
 +/**
 + * free_dma_rx_desc_resources - free RX dma desc resources
 + * @priv: private structure
 +
 +              kfree(rx_q->rx_skbuff_dma);
 +              kfree(rx_q->rx_skbuff);
-       }
- }
- /**
-- * alloc_dma_desc_resources - alloc TX/RX resources.
++      }
++}
++
++/**
 + * free_dma_tx_desc_resources - free TX dma desc resources
 + * @priv: private structure
 + */
 +
 +/**
 + * alloc_dma_rx_desc_resources - alloc RX resources.
-  * @priv: private structure
-  * Description: according to which descriptor can be used (extend or basic)
-  * this function allocates the resources for TX and RX paths. In case of
-  * reception, for example, it pre-allocated the RX socket buffer in order to
-  * allow zero-copy mechanism.
-  */
--static int alloc_dma_desc_resources(struct stmmac_priv *priv)
++ * @priv: private structure
++ * Description: according to which descriptor can be used (extend or basic)
++ * this function allocates the resources for TX and RX paths. In case of
++ * reception, for example, it pre-allocated the RX socket buffer in order to
++ * allow zero-copy mechanism.
++ */
 +static int alloc_dma_rx_desc_resources(struct stmmac_priv *priv)
- {
++{
 +      u32 rx_count = priv->plat->rx_queues_to_use;
-       int ret = -ENOMEM;
++      int ret = -ENOMEM;
 +      u32 queue;
--      priv->rx_skbuff_dma = kmalloc_array(DMA_RX_SIZE, sizeof(dma_addr_t),
--                                          GFP_KERNEL);
--      if (!priv->rx_skbuff_dma)
--              return -ENOMEM;
++
 +      /* RX queues buffers and DMA */
 +      for (queue = 0; queue < rx_count; queue++) {
 +              struct stmmac_rx_queue *rx_q = &priv->rx_queue[queue];
--      priv->rx_skbuff = kmalloc_array(DMA_RX_SIZE, sizeof(struct sk_buff *),
--                                      GFP_KERNEL);
--      if (!priv->rx_skbuff)
--              goto err_rx_skbuff;
--
--      priv->tx_skbuff_dma = kmalloc_array(DMA_TX_SIZE,
--                                          sizeof(*priv->tx_skbuff_dma),
--                                          GFP_KERNEL);
--      if (!priv->tx_skbuff_dma)
--              goto err_tx_skbuff_dma;
--
--      priv->tx_skbuff = kmalloc_array(DMA_TX_SIZE, sizeof(struct sk_buff *),
--                                      GFP_KERNEL);
--      if (!priv->tx_skbuff)
--              goto err_tx_skbuff;
--
--      if (priv->extend_desc) {
--              priv->dma_erx = dma_zalloc_coherent(priv->device, DMA_RX_SIZE *
--                                                  sizeof(struct
--                                                         dma_extended_desc),
--                                                  &priv->dma_rx_phy,
--                                                  GFP_KERNEL);
--              if (!priv->dma_erx)
--                      goto err_dma;
++
 +              rx_q->queue_index = queue;
 +              rx_q->priv_data = priv;
--              priv->dma_etx = dma_zalloc_coherent(priv->device, DMA_TX_SIZE *
--                                                  sizeof(struct
--                                                         dma_extended_desc),
--                                                  &priv->dma_tx_phy,
++
 +              rx_q->rx_skbuff_dma = kmalloc_array(DMA_RX_SIZE,
 +                                                  sizeof(dma_addr_t),
-                                                   GFP_KERNEL);
--              if (!priv->dma_etx) {
--                      dma_free_coherent(priv->device, DMA_RX_SIZE *
--                                        sizeof(struct dma_extended_desc),
--                                        priv->dma_erx, priv->dma_rx_phy);
--                      goto err_dma;
--              }
--      } else {
--              priv->dma_rx = dma_zalloc_coherent(priv->device, DMA_RX_SIZE *
--                                                 sizeof(struct dma_desc),
--                                                 &priv->dma_rx_phy,
--                                                 GFP_KERNEL);
--              if (!priv->dma_rx)
--                      goto err_dma;
++                                                  GFP_KERNEL);
 +              if (!rx_q->rx_skbuff_dma)
 +                      return -ENOMEM;
--              priv->dma_tx = dma_zalloc_coherent(priv->device, DMA_TX_SIZE *
--                                                 sizeof(struct dma_desc),
--                                                 &priv->dma_tx_phy,
--                                                 GFP_KERNEL);
--              if (!priv->dma_tx) {
--                      dma_free_coherent(priv->device, DMA_RX_SIZE *
--                                        sizeof(struct dma_desc),
--                                        priv->dma_rx, priv->dma_rx_phy);
++
 +              rx_q->rx_skbuff = kmalloc_array(DMA_RX_SIZE,
 +                                              sizeof(struct sk_buff *),
 +                                              GFP_KERNEL);
 +              if (!rx_q->rx_skbuff)
-                       goto err_dma;
++                      goto err_dma;
 +
 +              if (priv->extend_desc) {
 +                      rx_q->dma_erx = dma_zalloc_coherent(priv->device,
 +                                                         GFP_KERNEL);
 +                      if (!rx_q->dma_rx)
 +                              goto err_dma;
-               }
-       }
-       return 0;
- err_dma:
--      kfree(priv->tx_skbuff);
--err_tx_skbuff:
--      kfree(priv->tx_skbuff_dma);
--err_tx_skbuff_dma:
--      kfree(priv->rx_skbuff);
--err_rx_skbuff:
--      kfree(priv->rx_skbuff_dma);
++              }
++      }
++
++      return 0;
++
++err_dma:
 +      free_dma_rx_desc_resources(priv);
 +
 +      return ret;
 +                                                         GFP_KERNEL);
 +                      if (!tx_q->dma_tx)
 +                              goto err_dma_buffers;
-+              }
+               }
 +      }
 +
 +      return 0;
 +
 +      ret = alloc_dma_tx_desc_resources(priv);
 +
-       return ret;
- }
++      return ret;
++}
++
 +/**
 + * free_dma_desc_resources - free dma desc resources
 + * @priv: private structure
 + */
- static void free_dma_desc_resources(struct stmmac_priv *priv)
- {
--      /* Release the DMA TX/RX socket buffers */
--      dma_free_rx_skbufs(priv);
--      dma_free_tx_skbufs(priv);
--
--      /* Free DMA regions of consistent memory previously allocated */
--      if (!priv->extend_desc) {
--              dma_free_coherent(priv->device,
--                                DMA_TX_SIZE * sizeof(struct dma_desc),
--                                priv->dma_tx, priv->dma_tx_phy);
--              dma_free_coherent(priv->device,
--                                DMA_RX_SIZE * sizeof(struct dma_desc),
--                                priv->dma_rx, priv->dma_rx_phy);
--      } else {
--              dma_free_coherent(priv->device, DMA_TX_SIZE *
--                                sizeof(struct dma_extended_desc),
--                                priv->dma_etx, priv->dma_tx_phy);
--              dma_free_coherent(priv->device, DMA_RX_SIZE *
--                                sizeof(struct dma_extended_desc),
--                                priv->dma_erx, priv->dma_rx_phy);
--      }
--      kfree(priv->rx_skbuff_dma);
--      kfree(priv->rx_skbuff);
--      kfree(priv->tx_skbuff_dma);
--      kfree(priv->tx_skbuff);
++static void free_dma_desc_resources(struct stmmac_priv *priv)
++{
 +      /* Release the DMA RX socket buffers */
 +      free_dma_rx_desc_resources(priv);
 +
 +      /* Release the DMA TX socket buffers */
 +      free_dma_tx_desc_resources(priv);
- }
- /**
-@@ -1271,19 +1646,104 @@ static void free_dma_desc_resources(stru
-  */
- static void stmmac_mac_enable_rx_queues(struct stmmac_priv *priv)
- {
--      int rx_count = priv->dma_cap.number_rx_queues;
--      int queue = 0;
++}
++
++/**
++ *  stmmac_mac_enable_rx_queues - Enable MAC rx queues
++ *  @priv: driver private structure
++ *  Description: It is used for enabling the rx queues in the MAC
++ */
++static void stmmac_mac_enable_rx_queues(struct stmmac_priv *priv)
++{
 +      u32 rx_queues_count = priv->plat->rx_queues_to_use;
 +      int queue;
 +      u8 mode;
  
--      /* If GMAC does not have multiple queues, then this is not necessary*/
--      if (rx_count == 1)
--              return;
+-              if (priv->tx_skbuff[i]) {
+-                      dev_kfree_skb_any(priv->tx_skbuff[i]);
+-                      priv->tx_skbuff[i] = NULL;
+-                      priv->tx_skbuff_dma[i].buf = 0;
+-                      priv->tx_skbuff_dma[i].map_as_page = false;
+-              }
 +      for (queue = 0; queue < rx_queues_count; queue++) {
 +              mode = priv->plat->rx_queues_cfg[queue].mode_to_use;
 +              priv->hw->mac->rx_queue_enable(priv->hw, mode, queue);
-+      }
-+}
+       }
+ }
  
--      /**
--       *  If the core is synthesized with multiple rx queues / multiple
--       *  dma channels, then rx queues will be disabled by default.
--       *  For now only rx queue 0 is enabled.
--       */
--      priv->hw->mac->rx_queue_enable(priv->hw, queue);
-+/**
+ /**
+- * alloc_dma_desc_resources - alloc TX/RX resources.
+- * @priv: private structure
+- * Description: according to which descriptor can be used (extend or basic)
+- * this function allocates the resources for TX and RX paths. In case of
+- * reception, for example, it pre-allocated the RX socket buffer in order to
+- * allow zero-copy mechanism.
 + * stmmac_start_rx_dma - start RX DMA channel
 + * @priv: driver private structure
 + * @chan: RX channel index
 + * Description:
 + * This starts a RX DMA channel
-+ */
+  */
+-static int alloc_dma_desc_resources(struct stmmac_priv *priv)
 +static void stmmac_start_rx_dma(struct stmmac_priv *priv, u32 chan)
-+{
+ {
+-      int ret = -ENOMEM;
+-
+-      priv->rx_skbuff_dma = kmalloc_array(DMA_RX_SIZE, sizeof(dma_addr_t),
+-                                          GFP_KERNEL);
+-      if (!priv->rx_skbuff_dma)
+-              return -ENOMEM;
+-
+-      priv->rx_skbuff = kmalloc_array(DMA_RX_SIZE, sizeof(struct sk_buff *),
+-                                      GFP_KERNEL);
+-      if (!priv->rx_skbuff)
+-              goto err_rx_skbuff;
+-
+-      priv->tx_skbuff_dma = kmalloc_array(DMA_TX_SIZE,
+-                                          sizeof(*priv->tx_skbuff_dma),
+-                                          GFP_KERNEL);
+-      if (!priv->tx_skbuff_dma)
+-              goto err_tx_skbuff_dma;
+-
+-      priv->tx_skbuff = kmalloc_array(DMA_TX_SIZE, sizeof(struct sk_buff *),
+-                                      GFP_KERNEL);
+-      if (!priv->tx_skbuff)
+-              goto err_tx_skbuff;
+-
+-      if (priv->extend_desc) {
+-              priv->dma_erx = dma_zalloc_coherent(priv->device, DMA_RX_SIZE *
+-                                                  sizeof(struct
+-                                                         dma_extended_desc),
+-                                                  &priv->dma_rx_phy,
+-                                                  GFP_KERNEL);
+-              if (!priv->dma_erx)
+-                      goto err_dma;
+-
+-              priv->dma_etx = dma_zalloc_coherent(priv->device, DMA_TX_SIZE *
+-                                                  sizeof(struct
+-                                                         dma_extended_desc),
+-                                                  &priv->dma_tx_phy,
+-                                                  GFP_KERNEL);
+-              if (!priv->dma_etx) {
+-                      dma_free_coherent(priv->device, DMA_RX_SIZE *
+-                                        sizeof(struct dma_extended_desc),
+-                                        priv->dma_erx, priv->dma_rx_phy);
+-                      goto err_dma;
+-              }
+-      } else {
+-              priv->dma_rx = dma_zalloc_coherent(priv->device, DMA_RX_SIZE *
+-                                                 sizeof(struct dma_desc),
+-                                                 &priv->dma_rx_phy,
+-                                                 GFP_KERNEL);
+-              if (!priv->dma_rx)
+-                      goto err_dma;
 +      netdev_dbg(priv->dev, "DMA RX processes started in channel %d\n", chan);
 +      priv->hw->dma->start_rx(priv->ioaddr, chan);
 +}
-+
+-              priv->dma_tx = dma_zalloc_coherent(priv->device, DMA_TX_SIZE *
+-                                                 sizeof(struct dma_desc),
+-                                                 &priv->dma_tx_phy,
+-                                                 GFP_KERNEL);
+-              if (!priv->dma_tx) {
+-                      dma_free_coherent(priv->device, DMA_RX_SIZE *
+-                                        sizeof(struct dma_desc),
+-                                        priv->dma_rx, priv->dma_rx_phy);
+-                      goto err_dma;
+-              }
+-      }
 +/**
 + * stmmac_start_tx_dma - start TX DMA channel
 + * @priv: driver private structure
 +      netdev_dbg(priv->dev, "DMA TX processes started in channel %d\n", chan);
 +      priv->hw->dma->start_tx(priv->ioaddr, chan);
 +}
-+
+-      return 0;
 +/**
 + * stmmac_stop_rx_dma - stop RX DMA channel
 + * @priv: driver private structure
 +      netdev_dbg(priv->dev, "DMA RX processes stopped in channel %d\n", chan);
 +      priv->hw->dma->stop_rx(priv->ioaddr, chan);
 +}
-+
+-err_dma:
+-      kfree(priv->tx_skbuff);
+-err_tx_skbuff:
+-      kfree(priv->tx_skbuff_dma);
+-err_tx_skbuff_dma:
+-      kfree(priv->rx_skbuff);
+-err_rx_skbuff:
+-      kfree(priv->rx_skbuff_dma);
+-      return ret;
 +/**
 + * stmmac_stop_tx_dma - stop TX DMA channel
 + * @priv: driver private structure
 +{
 +      netdev_dbg(priv->dev, "DMA TX processes stopped in channel %d\n", chan);
 +      priv->hw->dma->stop_tx(priv->ioaddr, chan);
-+}
-+
+ }
+-static void free_dma_desc_resources(struct stmmac_priv *priv)
 +/**
 + * stmmac_start_all_dma - start all RX and TX DMA channels
 + * @priv: driver private structure
 + * This starts all the RX and TX DMA channels
 + */
 +static void stmmac_start_all_dma(struct stmmac_priv *priv)
-+{
+ {
+-      /* Release the DMA TX/RX socket buffers */
+-      dma_free_rx_skbufs(priv);
+-      dma_free_tx_skbufs(priv);
+-
+-      /* Free DMA regions of consistent memory previously allocated */
+-      if (!priv->extend_desc) {
+-              dma_free_coherent(priv->device,
+-                                DMA_TX_SIZE * sizeof(struct dma_desc),
+-                                priv->dma_tx, priv->dma_tx_phy);
+-              dma_free_coherent(priv->device,
+-                                DMA_RX_SIZE * sizeof(struct dma_desc),
+-                                priv->dma_rx, priv->dma_rx_phy);
+-      } else {
+-              dma_free_coherent(priv->device, DMA_TX_SIZE *
+-                                sizeof(struct dma_extended_desc),
+-                                priv->dma_etx, priv->dma_tx_phy);
+-              dma_free_coherent(priv->device, DMA_RX_SIZE *
+-                                sizeof(struct dma_extended_desc),
+-                                priv->dma_erx, priv->dma_rx_phy);
+-      }
+-      kfree(priv->rx_skbuff_dma);
+-      kfree(priv->rx_skbuff);
+-      kfree(priv->tx_skbuff_dma);
+-      kfree(priv->tx_skbuff);
 +      u32 rx_channels_count = priv->plat->rx_queues_to_use;
 +      u32 tx_channels_count = priv->plat->tx_queues_to_use;
 +      u32 chan = 0;
 +
 +      for (chan = 0; chan < tx_channels_count; chan++)
 +              stmmac_start_tx_dma(priv, chan);
-+}
-+
-+/**
+ }
+ /**
+- *  stmmac_mac_enable_rx_queues - Enable MAC rx queues
+- *  @priv: driver private structure
+- *  Description: It is used for enabling the rx queues in the MAC
 + * stmmac_stop_all_dma - stop all RX and TX DMA channels
 + * @priv: driver private structure
 + * Description:
 + * This stops the RX and TX DMA channels
-+ */
+  */
+-static void stmmac_mac_enable_rx_queues(struct stmmac_priv *priv)
 +static void stmmac_stop_all_dma(struct stmmac_priv *priv)
-+{
+ {
+-      int rx_count = priv->dma_cap.number_rx_queues;
+-      int queue = 0;
 +      u32 rx_channels_count = priv->plat->rx_queues_to_use;
 +      u32 tx_channels_count = priv->plat->tx_queues_to_use;
 +      u32 chan = 0;
-+
+-      /* If GMAC does not have multiple queues, then this is not necessary*/
+-      if (rx_count == 1)
+-              return;
 +      for (chan = 0; chan < rx_channels_count; chan++)
 +              stmmac_stop_rx_dma(priv, chan);
-+
+-      /**
+-       *  If the core is synthesized with multiple rx queues / multiple
+-       *  dma channels, then rx queues will be disabled by default.
+-       *  For now only rx queue 0 is enabled.
+-       */
+-      priv->hw->mac->rx_queue_enable(priv->hw, queue);
 +      for (chan = 0; chan < tx_channels_count; chan++)
 +              stmmac_stop_tx_dma(priv, chan);
  }