Changeset 9285


Ignore:
Timestamp:
2007-10-13T12:02:27+02:00 (10 years ago)
Author:
nbd
Message:

Finally fix the annoying BCM4704 segfault issues (#2035) - tested with WL-500gP
Thanks to jhansen and Wolfram Joost for the fixes and to ryd for the test hardware.
Seems like the user space segfaults actually came from this patch: http://lkml.org/lkml/2006/12/12/158

Location:
trunk/target/linux/brcm47xx
Files:
2 added
1 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm47xx/Makefile

    r8695 r9285  
    1212FEATURES:=squashfs usb 
    1313 
    14 LINUX_VERSION:=2.6.22.4 
     14LINUX_VERSION:=2.6.23 
    1515 
    1616include $(INCLUDE_DIR)/target.mk 
  • trunk/target/linux/brcm47xx/patches-2.6.23/120-b44_ssb_support.patch

    r9279 r9285  
    11Index: linux-2.6.23/drivers/net/b44.c 
    22=================================================================== 
    3 --- linux-2.6.23.orig/drivers/net/b44.c 2007-10-09 22:31:38.000000000 +0200 
    4 +++ linux-2.6.23/drivers/net/b44.c      2007-10-13 02:46:38.946989430 +0200 
     3--- linux-2.6.23.orig/drivers/net/b44.c 2007-10-13 10:58:27.872607266 +0200 
     4+++ linux-2.6.23/drivers/net/b44.c      2007-10-13 11:00:46.916530927 +0200 
    55@@ -1,7 +1,9 @@ 
    66-/* b44.c: Broadcom 4400 device driver. 
     
    108108+                                              enum dma_data_direction dir) 
    109109+{ 
    110 +       dma_sync_single_range_for_device(&sdev->dev, dma_base, 
     110+       dma_sync_single_range_for_device(sdev->dev, dma_base, 
    111111+                                       offset & dma_desc_align_mask, 
    112112+                                       dma_desc_sync_size, dir); 
     
    118118+                                           enum dma_data_direction dir) 
    119119+{ 
    120 +       dma_sync_single_range_for_cpu(&sdev->dev, dma_base, 
     120+       dma_sync_single_range_for_cpu(sdev->dev, dma_base, 
    121121+                                    offset & dma_desc_align_mask, 
    122122+                                    dma_desc_sync_size, dir); 
     
    371371  
    372372-               pci_unmap_single(bp->pdev, 
    373 +               dma_unmap_single(&bp->sdev->dev, 
     373+               dma_unmap_single(bp->sdev->dev, 
    374374                                 pci_unmap_addr(rp, mapping), 
    375375                                 skb->len, 
     
    384384  
    385385-       mapping = pci_map_single(bp->pdev, skb->data, 
    386 +       mapping = dma_map_single(&bp->sdev->dev, skb->data, 
     386+       mapping = dma_map_single(bp->sdev->dev, skb->data, 
    387387                                 RX_PKT_BUF_SZ, 
    388388-                                PCI_DMA_FROMDEVICE); 
     
    396396                if (!dma_mapping_error(mapping)) 
    397397-                       pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE); 
    398 +                       dma_unmap_single(&bp->sdev->dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE); 
     398+                       dma_unmap_single(bp->sdev->dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE); 
    399399                dev_kfree_skb_any(skb); 
    400400                skb = __netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ, GFP_ATOMIC|GFP_DMA); 
     
    402402                        return -ENOMEM; 
    403403-               mapping = pci_map_single(bp->pdev, skb->data, 
    404 +               mapping = dma_map_single(&bp->sdev->dev, skb->data, 
     404+               mapping = dma_map_single(bp->sdev->dev, skb->data, 
    405405                                         RX_PKT_BUF_SZ, 
    406406-                                        PCI_DMA_FROMDEVICE); 
     
    410410                        if (!dma_mapping_error(mapping)) 
    411411-                               pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE); 
    412 +                               dma_unmap_single(&bp->sdev->dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE); 
     412+                               dma_unmap_single(bp->sdev->dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE); 
    413413                        dev_kfree_skb_any(skb); 
    414414                        return -ENOMEM; 
     
    452452  
    453453-       pci_dma_sync_single_for_device(bp->pdev, le32_to_cpu(src_desc->addr), 
    454 +       dma_sync_single_for_device(&bp->sdev->dev, le32_to_cpu(src_desc->addr), 
     454+       dma_sync_single_for_device(bp->sdev->dev, le32_to_cpu(src_desc->addr), 
    455455                                       RX_PKT_BUF_SZ, 
    456456-                                      PCI_DMA_FROMDEVICE); 
     
    464464  
    465465-               pci_dma_sync_single_for_cpu(bp->pdev, map, 
    466 +               dma_sync_single_for_cpu(&bp->sdev->dev, map, 
     466+               dma_sync_single_for_cpu(bp->sdev->dev, map, 
    467467                                            RX_PKT_BUF_SZ, 
    468468-                                           PCI_DMA_FROMDEVICE); 
     
    477477-                       pci_unmap_single(bp->pdev, map, 
    478478-                                        skb_size, PCI_DMA_FROMDEVICE); 
    479 +                       dma_unmap_single(&bp->sdev->dev, map, 
     479+                       dma_unmap_single(bp->sdev->dev, map, 
    480480+                                        skb_size, DMA_FROM_DEVICE); 
    481481                        /* Leave out rx_header */ 
     
    487487  
    488488-       mapping = pci_map_single(bp->pdev, skb->data, len, PCI_DMA_TODEVICE); 
    489 +       mapping = dma_map_single(&bp->sdev->dev, skb->data, len, DMA_TO_DEVICE); 
     489+       mapping = dma_map_single(bp->sdev->dev, skb->data, len, DMA_TO_DEVICE); 
    490490        if (dma_mapping_error(mapping) || mapping + len > DMA_30BIT_MASK) { 
    491491                struct sk_buff *bounce_skb; 
     
    494494                if (!dma_mapping_error(mapping)) 
    495495-                       pci_unmap_single(bp->pdev, mapping, len, PCI_DMA_TODEVICE); 
    496 +                       dma_unmap_single(&bp->sdev->dev, mapping, len, DMA_TO_DEVICE); 
     496+                       dma_unmap_single(bp->sdev->dev, mapping, len, DMA_TO_DEVICE); 
    497497  
    498498                bounce_skb = __dev_alloc_skb(len, GFP_ATOMIC | GFP_DMA); 
     
    502502-               mapping = pci_map_single(bp->pdev, bounce_skb->data, 
    503503-                                        len, PCI_DMA_TODEVICE); 
    504 +               mapping = dma_map_single(&bp->sdev->dev, bounce_skb->data, 
     504+               mapping = dma_map_single(bp->sdev->dev, bounce_skb->data, 
    505505+                                        len, DMA_TO_DEVICE); 
    506506                if (dma_mapping_error(mapping) || mapping + len > DMA_30BIT_MASK) { 
     
    508508-                               pci_unmap_single(bp->pdev, mapping, 
    509509-                                                len, PCI_DMA_TODEVICE); 
    510 +                               dma_unmap_single(&bp->sdev->dev, mapping, 
     510+                               dma_unmap_single(bp->sdev->dev, mapping, 
    511511+                                                len, DMA_TO_DEVICE); 
    512512                        dev_kfree_skb_any(bounce_skb); 
     
    531531                        continue; 
    532532-               pci_unmap_single(bp->pdev, 
    533 +               dma_unmap_single(&bp->sdev->dev, 
     533+               dma_unmap_single(bp->sdev->dev, 
    534534                                 pci_unmap_addr(rp, mapping), 
    535535                                 RX_PKT_BUF_SZ, 
     
    544544                        continue; 
    545545-               pci_unmap_single(bp->pdev, 
    546 +               dma_unmap_single(&bp->sdev->dev, 
     546+               dma_unmap_single(bp->sdev->dev, 
    547547                                 pci_unmap_addr(rp, mapping), 
    548548                                 rp->skb->len, 
     
    559559-                                          DMA_TABLE_BYTES, 
    560560-                                          PCI_DMA_BIDIRECTIONAL); 
    561 +               dma_sync_single_for_device(&bp->sdev->dev, bp->rx_ring_dma, 
     561+               dma_sync_single_for_device(bp->sdev->dev, bp->rx_ring_dma, 
    562562+                                         DMA_TABLE_BYTES, 
    563563+                                         DMA_BIDIRECTIONAL); 
     
    567567-                                          DMA_TABLE_BYTES, 
    568568-                                          PCI_DMA_TODEVICE); 
    569 +               dma_sync_single_for_device(&bp->sdev->dev, bp->tx_ring_dma, 
     569+               dma_sync_single_for_device(bp->sdev->dev, bp->tx_ring_dma, 
    570570+                                         DMA_TABLE_BYTES, 
    571571+                                         DMA_TO_DEVICE); 
     
    580580-                                        DMA_TABLE_BYTES, 
    581581-                                        DMA_BIDIRECTIONAL); 
    582 +                       dma_unmap_single(&bp->sdev->dev, bp->rx_ring_dma, 
     582+                       dma_unmap_single(bp->sdev->dev, bp->rx_ring_dma, 
    583583+                                       DMA_TABLE_BYTES, 
    584584+                                       DMA_BIDIRECTIONAL); 
     
    586586                } else 
    587587-                       pci_free_consistent(bp->pdev, DMA_TABLE_BYTES, 
    588 +                       dma_free_coherent(&bp->sdev->dev, DMA_TABLE_BYTES, 
     588+                       dma_free_coherent(bp->sdev->dev, DMA_TABLE_BYTES, 
    589589                                            bp->rx_ring, bp->rx_ring_dma); 
    590590                bp->rx_ring = NULL; 
     
    596596-                                        DMA_TABLE_BYTES, 
    597597-                                        DMA_TO_DEVICE); 
    598 +                       dma_unmap_single(&bp->sdev->dev, bp->tx_ring_dma, 
     598+                       dma_unmap_single(bp->sdev->dev, bp->tx_ring_dma, 
    599599+                                       DMA_TABLE_BYTES, 
    600600+                                       DMA_TO_DEVICE); 
     
    602602                } else 
    603603-                       pci_free_consistent(bp->pdev, DMA_TABLE_BYTES, 
    604 +                       dma_free_coherent(&bp->sdev->dev, DMA_TABLE_BYTES, 
     604+                       dma_free_coherent(bp->sdev->dev, DMA_TABLE_BYTES, 
    605605                                            bp->tx_ring, bp->tx_ring_dma); 
    606606                bp->tx_ring = NULL; 
     
    611611        size = DMA_TABLE_BYTES; 
    612612-       bp->rx_ring = pci_alloc_consistent(bp->pdev, size, &bp->rx_ring_dma); 
    613 +       bp->rx_ring = dma_alloc_coherent(&bp->sdev->dev, size, &bp->rx_ring_dma, GFP_ATOMIC); 
     613+       bp->rx_ring = dma_alloc_coherent(bp->sdev->dev, size, &bp->rx_ring_dma, GFP_ATOMIC); 
    614614        if (!bp->rx_ring) { 
    615615                /* Allocation may have failed due to pci_alloc_consistent 
     
    622622-                                            DMA_TABLE_BYTES, 
    623623-                                            DMA_BIDIRECTIONAL); 
    624 +               rx_ring_dma = dma_map_single(&bp->sdev->dev, rx_ring, 
     624+               rx_ring_dma = dma_map_single(bp->sdev->dev, rx_ring, 
    625625+                                           DMA_TABLE_BYTES, 
    626626+                                           DMA_BIDIRECTIONAL); 
     
    633633  
    634634-       bp->tx_ring = pci_alloc_consistent(bp->pdev, size, &bp->tx_ring_dma); 
    635 +       bp->tx_ring = dma_alloc_coherent(&bp->sdev->dev, size, &bp->tx_ring_dma, GFP_ATOMIC); 
     635+       bp->tx_ring = dma_alloc_coherent(bp->sdev->dev, size, &bp->tx_ring_dma, GFP_ATOMIC); 
    636636        if (!bp->tx_ring) { 
    637637-               /* Allocation may have failed due to pci_alloc_consistent 
     
    647647-                                            DMA_TABLE_BYTES, 
    648648-                                            DMA_TO_DEVICE); 
    649 +               tx_ring_dma = dma_map_single(&bp->sdev->dev, tx_ring, 
     649+               tx_ring_dma = dma_map_single(bp->sdev->dev, tx_ring, 
    650650+                                           DMA_TABLE_BYTES, 
    651651+                                           DMA_TO_DEVICE); 
     
    11161116        if (!is_valid_ether_addr(&bp->dev->dev_addr[0])){ 
    11171117                printk(KERN_ERR PFX "Invalid MAC address found in EEPROM\n"); 
    1118 @@ -2086,26 +2282,20 @@ 
     1118@@ -2086,103 +2282,52 @@ 
    11191119  
    11201120        memcpy(bp->dev->perm_addr, bp->dev->dev_addr, bp->dev->addr_len); 
     
    11321132  
    11331133-       if (ssb_get_core_rev(bp) >= 7) 
    1134 +       if (bp->sdev->dev->id.revision >= 7) 
     1134+       if (bp->sdev->id.revision >= 7) 
    11351135                bp->flags |= B44_FLAG_B0_ANDLATER; 
    11361136  
     
    11451145 { 
    11461146        static int b44_version_printed = 0; 
    1147         unsigned long b44reg_base, b44reg_len; 
    1148 @@ -2113,76 +2303,32 @@ 
     1147-       unsigned long b44reg_base, b44reg_len; 
     1148        struct net_device *dev; 
    11491149        struct b44 *bp; 
    11501150        int err, i; 
     
    11961196        dev = alloc_etherdev(sizeof(*bp)); 
    11971197        if (!dev) { 
    1198                 dev_err(&pdev->dev, "Etherdev alloc failed, aborting.\n"); 
     1198-               dev_err(&pdev->dev, "Etherdev alloc failed, aborting.\n"); 
     1199+               dev_err(sdev->dev, "Etherdev alloc failed, aborting.\n"); 
    11991200                err = -ENOMEM; 
    12001201-               goto err_out_free_res; 
     
    12041205        SET_MODULE_OWNER(dev); 
    12051206-       SET_NETDEV_DEV(dev,&pdev->dev); 
    1206 +       SET_NETDEV_DEV(dev,&sdev->dev); 
     1207+       SET_NETDEV_DEV(dev,sdev->dev); 
    12071208  
    12081209        /* No interesting netdevice features in this card... */ 
     
    12281229        bp->tx_pending = B44_DEF_TX_RING_PENDING; 
    12291230  
    1230 @@ -2201,16 +2347,16 @@ 
     1231@@ -2201,16 +2346,16 @@ 
    12311232        dev->poll_controller = b44_poll_controller; 
    12321233 #endif 
     
    12411242        if (err) { 
    12421243-               dev_err(&pdev->dev, 
    1243 +               dev_err(&sdev->dev, 
     1244+               dev_err(sdev->dev, 
    12441245                        "Problem fetching invariants of chip, aborting.\n"); 
    12451246-               goto err_out_iounmap; 
     
    12481249  
    12491250        bp->mii_if.dev = dev; 
    1250 @@ -2229,61 +2375,52 @@ 
     1251@@ -2229,61 +2374,52 @@ 
    12511252  
    12521253        err = register_netdev(dev); 
     
    12541255-               dev_err(&pdev->dev, "Cannot register net device, aborting.\n"); 
    12551256-               goto err_out_iounmap; 
    1256 +               dev_err(&sdev->dev, "Cannot register net device, aborting.\n"); 
     1257+               dev_err(sdev->dev, "Cannot register net device, aborting.\n"); 
    12571258+               goto out; 
    12581259        } 
     
    13261327        del_timer_sync(&bp->timer); 
    13271328  
    1328 @@ -2301,26 +2438,16 @@ 
     1329@@ -2301,33 +2437,22 @@ 
    13291330                b44_init_hw(bp, B44_PARTIAL_RESET); 
    13301331                b44_setup_wol(bp); 
     
    13561357                return 0; 
    13571358  
    1358 @@ -2346,29 +2473,31 @@ 
     1359        rc = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev); 
     1360        if (rc) { 
     1361                printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name); 
     1362-               pci_disable_device(pdev); 
     1363                return rc; 
     1364        } 
     1365  
     1366@@ -2346,29 +2471,31 @@ 
    13591367        return 0; 
    13601368 } 
     
    13961404Index: linux-2.6.23/drivers/net/b44.h 
    13971405=================================================================== 
    1398 --- linux-2.6.23.orig/drivers/net/b44.h 2007-10-09 22:31:38.000000000 +0200 
    1399 +++ linux-2.6.23/drivers/net/b44.h      2007-10-13 02:28:25.848697310 +0200 
     1406--- linux-2.6.23.orig/drivers/net/b44.h 2007-10-13 10:58:27.880607722 +0200 
     1407+++ linux-2.6.23/drivers/net/b44.h      2007-10-13 11:00:46.904530245 +0200 
    14001408@@ -129,6 +129,7 @@ 
    14011409 #define  RXCONFIG_FLOW         0x00000020 /* Flow Control Enable */ 
     
    15231531Index: linux-2.6.23/drivers/net/Kconfig 
    15241532=================================================================== 
    1525 --- linux-2.6.23.orig/drivers/net/Kconfig       2007-10-13 02:19:47.919182188 +0200 
    1526 +++ linux-2.6.23/drivers/net/Kconfig    2007-10-13 02:28:25.860697993 +0200 
     1533--- linux-2.6.23.orig/drivers/net/Kconfig       2007-10-13 10:58:27.888608180 +0200 
     1534+++ linux-2.6.23/drivers/net/Kconfig    2007-10-13 11:00:46.912530699 +0200 
    15271535@@ -1577,7 +1577,7 @@ 
    15281536  
  • trunk/target/linux/brcm47xx/patches-2.6.23/150-cpu_fixes.patch

    r9279 r9285  
    11Index: linux-2.6.23/arch/mips/kernel/genex.S 
    22=================================================================== 
    3 --- linux-2.6.23.orig/arch/mips/kernel/genex.S  2007-10-09 22:31:38.000000000 +0200 
    4 +++ linux-2.6.23/arch/mips/kernel/genex.S       2007-10-13 02:47:32.546043867 +0200 
     3--- linux-2.6.23.orig/arch/mips/kernel/genex.S  2007-10-13 11:29:46.219648163 +0200 
     4+++ linux-2.6.23/arch/mips/kernel/genex.S       2007-10-13 11:29:49.619841933 +0200 
    55@@ -51,6 +51,10 @@ 
    66 NESTED(except_vec3_generic, 0, sp) 
     
    1616Index: linux-2.6.23/arch/mips/mm/c-r4k.c 
    1717=================================================================== 
    18 --- linux-2.6.23.orig/arch/mips/mm/c-r4k.c      2007-10-13 02:47:02.792348301 +0200 
    19 +++ linux-2.6.23/arch/mips/mm/c-r4k.c   2007-10-13 02:55:35.877587360 +0200 
     18--- linux-2.6.23.orig/arch/mips/mm/c-r4k.c      2007-10-13 11:29:46.227648623 +0200 
     19+++ linux-2.6.23/arch/mips/mm/c-r4k.c   2007-10-13 11:29:49.619841933 +0200 
    2020@@ -30,6 +30,9 @@ 
    2121 #include <asm/cacheflush.h> /* for run_uncached() */ 
     
    2828  * Special Variant of smp_call_function for use by cache functions: 
    2929  * 
    30 @@ -86,14 +89,21 @@ 
    31   
    32  static inline void r4k_blast_dcache_page_dc32(unsigned long addr) 
    33  { 
    34 +       unsigned long flags; 
    35 + 
    36 +       local_irq_save(flags); 
    37         R4600_HIT_CACHEOP_WAR_IMPL; 
    38         blast_dcache32_page(addr); 
    39 +       local_irq_restore(flags); 
    40  } 
    41   
    42  static void __init r4k_blast_dcache_page_setup(void) 
     30@@ -94,6 +97,9 @@ 
    4331 { 
    4432        unsigned long  dc_lsize = cpu_dcache_line_size(); 
     
    5038                r4k_blast_dcache_page = (void *)cache_noop; 
    5139        else if (dc_lsize == 16) 
    52 @@ -108,6 +118,9 @@ 
     40@@ -108,6 +114,9 @@ 
    5341 { 
    5442        unsigned long dc_lsize = cpu_dcache_line_size(); 
     
    6048                r4k_blast_dcache_page_indexed = (void *)cache_noop; 
    6149        else if (dc_lsize == 16) 
    62 @@ -122,6 +135,9 @@ 
     50@@ -122,6 +131,9 @@ 
    6351 { 
    6452        unsigned long dc_lsize = cpu_dcache_line_size(); 
     
    7058                r4k_blast_dcache = (void *)cache_noop; 
    7159        else if (dc_lsize == 16) 
    72 @@ -203,8 +219,12 @@ 
    73   
    74  static void (* r4k_blast_icache_page)(unsigned long addr); 
    75   
    76 +static void r4k_flush_cache_all(void); 
    77  static void __init r4k_blast_icache_page_setup(void) 
    78  { 
    79 +#ifdef CONFIG_BCM947XX 
    80 +       r4k_blast_icache_page = (void *)r4k_flush_cache_all; 
    81 +#else 
    82         unsigned long ic_lsize = cpu_icache_line_size(); 
    83   
    84         if (ic_lsize == 0) 
    85 @@ -215,6 +235,7 @@ 
    86                 r4k_blast_icache_page = blast_icache32_page; 
    87         else if (ic_lsize == 64) 
    88                 r4k_blast_icache_page = blast_icache64_page; 
    89 +#endif 
    90  } 
    91   
    92   
    93 @@ -222,6 +243,9 @@ 
    94   
    95  static void __init r4k_blast_icache_page_indexed_setup(void) 
    96  { 
    97 +#ifdef CONFIG_BCM947XX 
    98 +       r4k_blast_icache_page_indexed = (void *)r4k_flush_cache_all; 
    99 +#else 
    100         unsigned long ic_lsize = cpu_icache_line_size(); 
    101   
    102         if (ic_lsize == 0) 
    103 @@ -240,6 +264,7 @@ 
    104                                 blast_icache32_page_indexed; 
    105         } else if (ic_lsize == 64) 
    106                 r4k_blast_icache_page_indexed = blast_icache64_page_indexed; 
    107 +#endif 
    108  } 
    109   
    110  static void (* r4k_blast_icache)(void); 
    111 @@ -323,12 +348,17 @@ 
    112   */ 
    113  static inline void local_r4k_flush_cache_all(void * args) 
    114  { 
    115 +       unsigned long flags; 
    116 + 
    117 +       local_irq_save(flags); 
    118         r4k_blast_dcache(); 
    119 +       r4k_blast_icache(); 
    120 +       local_irq_restore(flags); 
    121  } 
    122   
    123  static void r4k_flush_cache_all(void) 
    124  { 
    125 -       if (!cpu_has_dc_aliases) 
    126 +       if (!cpu_has_dc_aliases && cpu_use_kmap_coherent) 
    127                 return; 
    128   
    129         r4k_on_each_cpu(local_r4k_flush_cache_all, NULL, 1, 1); 
    130 @@ -336,6 +366,9 @@ 
    131   
    132  static inline void local_r4k___flush_cache_all(void * args) 
    133  { 
    134 +       unsigned long flags; 
    135 + 
    136 +       local_irq_save(flags); 
    137  #if defined(CONFIG_CPU_LOONGSON2) 
    138         r4k_blast_scache(); 
    139         return; 
    140 @@ -353,6 +386,7 @@ 
    141         case CPU_R14000: 
    142                 r4k_blast_scache(); 
    143         } 
    144 +       local_irq_restore(flags); 
    145  } 
    146   
    147  static void r4k___flush_cache_all(void) 
    148 @@ -363,17 +397,21 @@ 
    149  static inline void local_r4k_flush_cache_range(void * args) 
    150  { 
    151         struct vm_area_struct *vma = args; 
    152 +       unsigned long flags; 
    153   
    154         if (!(cpu_context(smp_processor_id(), vma->vm_mm))) 
    155                 return; 
    156   
    157 +       local_irq_save(flags); 
    158         r4k_blast_dcache(); 
    159 +       r4k_blast_icache(); 
    160 +       local_irq_restore(flags); 
    161  } 
    162   
    163  static void r4k_flush_cache_range(struct vm_area_struct *vma, 
    164         unsigned long start, unsigned long end) 
    165  { 
    166 -       if (!cpu_has_dc_aliases) 
    167 +       if (!cpu_has_dc_aliases && cpu_use_kmap_coherent) 
    168                 return; 
    169   
    170         r4k_on_each_cpu(local_r4k_flush_cache_range, vma, 1, 1); 
    171 @@ -382,6 +420,7 @@ 
    172  static inline void local_r4k_flush_cache_mm(void * args) 
    173  { 
    174         struct mm_struct *mm = args; 
    175 +       unsigned long flags; 
    176   
    177         if (!cpu_context(smp_processor_id(), mm)) 
    178                 return; 
    179 @@ -400,12 +439,15 @@ 
    180                 return; 
    181         } 
    182   
    183 +       local_irq_save(flags); 
    184         r4k_blast_dcache(); 
    185 +       r4k_blast_icache(); 
    186 +       local_irq_restore(flags); 
    187  } 
    188   
    189  static void r4k_flush_cache_mm(struct mm_struct *mm) 
    190  { 
    191 -       if (!cpu_has_dc_aliases) 
    192 +       if (!cpu_has_dc_aliases && cpu_use_kmap_coherent) 
    193                 return; 
    194   
    195         r4k_on_each_cpu(local_r4k_flush_cache_mm, mm, 1, 1); 
    196 @@ -425,6 +467,7 @@ 
    197         unsigned long paddr = fcp_args->pfn << PAGE_SHIFT; 
    198         int exec = vma->vm_flags & VM_EXEC; 
    199         struct mm_struct *mm = vma->vm_mm; 
    200 +       unsigned long flags; 
    201         pgd_t *pgdp; 
    202         pud_t *pudp; 
    203         pmd_t *pmdp; 
    204 @@ -456,8 +499,9 @@ 
    205          * for every cache flush operation.  So we do indexed flushes 
    206          * in that case, which doesn't overly flush the cache too much. 
    207          */ 
    208 +       local_irq_save(flags); 
    209         if ((mm == current->active_mm) && (pte_val(*ptep) & _PAGE_VALID)) { 
    210 -               if (cpu_has_dc_aliases || (exec && !cpu_has_ic_fills_f_dc)) { 
    211 +               if (!cpu_use_kmap_coherent || cpu_has_dc_aliases || (exec && !cpu_has_ic_fills_f_dc)) { 
    212                         r4k_blast_dcache_page(addr); 
    213                         if (exec && !cpu_icache_snoops_remote_store) 
    214                                 r4k_blast_scache_page(addr); 
    215 @@ -465,14 +509,14 @@ 
    216                 if (exec) 
    217                         r4k_blast_icache_page(addr); 
    218   
    219 -               return; 
    220 +               goto done; 
    221         } 
    222   
    223         /* 
    224          * Do indexed flush, too much work to get the (possible) TLB refills 
    225          * to work correctly. 
    226          */ 
    227 -       if (cpu_has_dc_aliases || (exec && !cpu_has_ic_fills_f_dc)) { 
    228 +       if (!cpu_use_kmap_coherent || cpu_has_dc_aliases || (exec && !cpu_has_ic_fills_f_dc)) { 
    229                 r4k_blast_dcache_page_indexed(cpu_has_pindexed_dcache ? 
    230                                               paddr : addr); 
    231                 if (exec && !cpu_icache_snoops_remote_store) { 
    232 @@ -488,6 +532,8 @@ 
    233                 } else 
    234                         r4k_blast_icache_page_indexed(addr); 
    235         } 
    236 +done: 
    237 +       local_irq_restore(flags); 
    238  } 
    239   
    240  static void r4k_flush_cache_page(struct vm_area_struct *vma, 
    241 @@ -504,7 +550,11 @@ 
    242   
    243  static inline void local_r4k_flush_data_cache_page(void * addr) 
    244  { 
    245 +       unsigned long flags; 
    246 + 
    247 +       local_irq_save(flags); 
    248         r4k_blast_dcache_page((unsigned long) addr); 
    249 +       local_irq_restore(flags); 
    250  } 
    251   
    252  static void r4k_flush_data_cache_page(unsigned long addr) 
    253 @@ -547,6 +597,9 @@ 
    254   
    255  static void r4k_flush_icache_range(unsigned long start, unsigned long end) 
    256  { 
    257 +#ifdef CONFIG_BCM947XX 
    258 +       r4k_flush_cache_all(); 
    259 +#else 
    260         struct flush_icache_range_args args; 
    261   
    262         args.start = start; 
    263 @@ -554,12 +607,15 @@ 
    264   
    265         r4k_on_each_cpu(local_r4k_flush_icache_range, &args, 1, 1); 
    266         instruction_hazard(); 
    267 +#endif 
    268  } 
    269   
    270  #ifdef CONFIG_DMA_NONCOHERENT 
    271   
    272  static void r4k_dma_cache_wback_inv(unsigned long addr, unsigned long size) 
    273  { 
    274 +       unsigned long flags; 
    275 + 
    276         /* Catch bad driver code */ 
    277         BUG_ON(size == 0); 
    278   
    279 @@ -576,18 +632,21 @@ 
    280          * subset property so we have to flush the primary caches 
    281          * explicitly 
    282          */ 
    283 +       local_irq_save(flags); 
    284         if (size >= dcache_size) { 
    285                 r4k_blast_dcache(); 
    286         } else { 
    287                 R4600_HIT_CACHEOP_WAR_IMPL; 
    288                 blast_dcache_range(addr, addr + size); 
    289         } 
    290 - 
    291         bc_wback_inv(addr, size); 
    292 +       local_irq_restore(flags); 
    293  } 
    294   
    295  static void r4k_dma_cache_inv(unsigned long addr, unsigned long size) 
    296  { 
    297 +       unsigned long flags; 
    298 + 
    299         /* Catch bad driver code */ 
    300         BUG_ON(size == 0); 
    301   
    302 @@ -599,6 +658,7 @@ 
    303                 return; 
    304         } 
    305   
    306 +       local_irq_save(flags); 
    307         if (size >= dcache_size) { 
    308                 r4k_blast_dcache(); 
    309         } else { 
    310 @@ -607,6 +667,7 @@ 
    311         } 
    312   
    313         bc_inv(addr, size); 
    314 +       local_irq_restore(flags); 
    315  } 
    316  #endif /* CONFIG_DMA_NONCOHERENT */ 
    317   
    318 @@ -621,8 +682,12 @@ 
    319         unsigned long dc_lsize = cpu_dcache_line_size(); 
    320         unsigned long sc_lsize = cpu_scache_line_size(); 
     60@@ -623,6 +635,8 @@ 
    32161        unsigned long addr = (unsigned long) arg; 
    322 +       unsigned long flags; 
    323   
    324 +       local_irq_save(flags); 
     62  
    32563        R4600_HIT_CACHEOP_WAR_IMPL; 
    32664+       BCM4710_PROTECTED_FILL_TLB(addr); 
     
    32967                protected_writeback_dcache_line(addr & ~(dc_lsize - 1)); 
    33068        if (!cpu_icache_snoops_remote_store && scache_size) 
    331 @@ -649,6 +714,7 @@ 
    332         } 
    333         if (MIPS_CACHE_SYNC_WAR) 
    334                 __asm__ __volatile__ ("sync"); 
    335 +       local_irq_restore(flags); 
    336  } 
    337   
    338  static void r4k_flush_cache_sigtramp(unsigned long addr) 
    339 @@ -1198,6 +1264,17 @@ 
     69@@ -1198,6 +1212,17 @@ 
    34070         * silly idea of putting something else there ... 
    34171         */ 
     
    35585        case CPU_R4000SC: 
    35686        case CPU_R4000MC: 
    357 @@ -1228,6 +1305,15 @@ 
     87@@ -1228,6 +1253,15 @@ 
    35888        /* Default cache error handler for R4000 and R5000 family */ 
    35989        set_uncached_handler (0x100, &except_vec2_generic, 0x80); 
     
    371101        setup_scache(); 
    372102  
    373 @@ -1273,5 +1359,13 @@ 
     103@@ -1273,5 +1307,13 @@ 
    374104        build_clear_page(); 
    375105        build_copy_page(); 
     
    387117Index: linux-2.6.23/arch/mips/mm/tlbex.c 
    388118=================================================================== 
    389 --- linux-2.6.23.orig/arch/mips/mm/tlbex.c      2007-10-13 02:26:00.272401391 +0200 
    390 +++ linux-2.6.23/arch/mips/mm/tlbex.c   2007-10-13 02:47:32.550044103 +0200 
    391 @@ -1247,6 +1247,10 @@ 
    392  #endif 
    393  } 
    394   
    395 +#ifdef CONFIG_BCM947XX 
    396 +extern int bcm4710; 
    397 +#endif 
    398 + 
    399  static void __init build_r4000_tlb_refill_handler(void) 
    400  { 
    401         u32 *p = tlb_handler; 
    402 @@ -1261,6 +1265,10 @@ 
    403         memset(relocs, 0, sizeof(relocs)); 
    404         memset(final_handler, 0, sizeof(final_handler)); 
     119--- linux-2.6.23.orig/arch/mips/mm/tlbex.c      2007-10-13 11:29:46.235649074 +0200 
     120+++ linux-2.6.23/arch/mips/mm/tlbex.c   2007-10-13 11:35:46.076155216 +0200 
     121@@ -1273,6 +1273,9 @@ 
     122                /* No need for i_nop */ 
     123        } 
    405124  
    406125+#ifdef CONFIG_BCM947XX 
    407126+       i_nop(&p); 
    408127+#endif 
    409 + 
    410         /* 
    411          * create the plain linear handler 
    412          */ 
    413 @@ -1756,6 +1764,9 @@ 
    414         memset(labels, 0, sizeof(labels)); 
    415         memset(relocs, 0, sizeof(relocs)); 
    416   
    417 +#ifdef CONFIG_BCM947XX 
    418 +       i_nop(&p); 
    419 +#endif 
    420         if (bcm1250_m3_war()) { 
    421                 i_MFC0(&p, K0, C0_BADVADDR); 
    422                 i_MFC0(&p, K1, C0_ENTRYHI); 
     128 #ifdef CONFIG_64BIT 
     129        build_get_pmde64(&p, &l, &r, K0, K1); /* get pmd in K1 */ 
     130 #else 
     131@@ -1708,6 +1711,9 @@ 
     132                                   struct reloc **r, unsigned int pte, 
     133                                   unsigned int ptr) 
     134 { 
     135+#ifdef CONFIG_BCM947XX 
     136+       i_nop(p); 
     137+#endif 
     138 #ifdef CONFIG_64BIT 
     139        build_get_pmde64(p, l, r, pte, ptr); /* get pmd in ptr */ 
     140 #else 
    423141Index: linux-2.6.23/include/asm-mips/r4kcache.h 
    424142=================================================================== 
    425 --- linux-2.6.23.orig/include/asm-mips/r4kcache.h       2007-10-09 22:31:38.000000000 +0200 
    426 +++ linux-2.6.23/include/asm-mips/r4kcache.h    2007-10-13 02:47:32.554044332 +0200 
     143--- linux-2.6.23.orig/include/asm-mips/r4kcache.h       2007-10-13 11:29:46.255650214 +0200 
     144+++ linux-2.6.23/include/asm-mips/r4kcache.h    2007-10-13 11:29:49.631842613 +0200 
    427145@@ -17,6 +17,20 @@ 
    428146 #include <asm/cpu-features.h> 
     
    629347Index: linux-2.6.23/include/asm-mips/stackframe.h 
    630348=================================================================== 
    631 --- linux-2.6.23.orig/include/asm-mips/stackframe.h     2007-10-09 22:31:38.000000000 +0200 
    632 +++ linux-2.6.23/include/asm-mips/stackframe.h  2007-10-13 02:47:32.554044332 +0200 
     349--- linux-2.6.23.orig/include/asm-mips/stackframe.h     2007-10-13 11:29:46.263650671 +0200 
     350+++ linux-2.6.23/include/asm-mips/stackframe.h  2007-10-13 11:33:38.504885346 +0200 
    633351@@ -350,6 +350,10 @@ 
    634352                .macro  RESTORE_SP_AND_RET 
Note: See TracChangeset for help on using the changeset viewer.