Changeset 20281


Ignore:
Timestamp:
2010-03-18T20:18:54+01:00 (8 years ago)
Author:
juhosg
Message:

ar71xx: move PCI intterupt handling code to pci-ar7{1xx,24x}.c

Location:
trunk/target/linux/ar71xx/files/arch/mips
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/arch/mips/ar71xx/irq.c

    r20280 r20281  
    2222#include <asm/mach-ar71xx/ar71xx.h> 
    2323 
    24 #ifdef CONFIG_PCI 
    25 static void ar71xx_pci_irq_handler(unsigned int irq, struct irq_desc *desc) 
    26 { 
    27         u32 pending; 
    28  
    29         pending = ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_STATUS) & 
    30                   ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE); 
    31  
    32         if (pending & PCI_INT_DEV0) 
    33                 generic_handle_irq(AR71XX_PCI_IRQ_DEV0); 
    34  
    35         else if (pending & PCI_INT_DEV1) 
    36                 generic_handle_irq(AR71XX_PCI_IRQ_DEV1); 
    37  
    38         else if (pending & PCI_INT_DEV2) 
    39                 generic_handle_irq(AR71XX_PCI_IRQ_DEV2); 
    40  
    41         else if (pending & PCI_INT_CORE) 
    42                 generic_handle_irq(AR71XX_PCI_IRQ_CORE); 
    43  
    44         else 
    45                 spurious_interrupt(); 
    46 } 
    47  
    48 static void ar71xx_pci_irq_unmask(unsigned int irq) 
    49 { 
    50         irq -= AR71XX_PCI_IRQ_BASE; 
    51         ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_ENABLE, 
    52                 ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE) | (1 << irq)); 
    53  
    54         /* flush write */ 
    55         ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE); 
    56 } 
    57  
    58 static void ar71xx_pci_irq_mask(unsigned int irq) 
    59 { 
    60         irq -= AR71XX_PCI_IRQ_BASE; 
    61         ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_ENABLE, 
    62                 ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE) & ~(1 << irq)); 
    63  
    64         /* flush write */ 
    65         ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE); 
    66 } 
    67  
    68 static struct irq_chip ar71xx_pci_irq_chip = { 
    69         .name           = "AR71XX PCI ", 
    70         .mask           = ar71xx_pci_irq_mask, 
    71         .unmask         = ar71xx_pci_irq_unmask, 
    72         .mask_ack       = ar71xx_pci_irq_mask, 
    73 }; 
    74  
    75 static void __init ar71xx_pci_irq_init(void) 
    76 { 
    77         int i; 
    78  
    79         ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_ENABLE, 0); 
    80         ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_STATUS, 0); 
    81  
    82         for (i = AR71XX_PCI_IRQ_BASE; 
    83              i < AR71XX_PCI_IRQ_BASE + AR71XX_PCI_IRQ_COUNT; i++) { 
    84                 irq_desc[i].status = IRQ_DISABLED; 
    85                 set_irq_chip_and_handler(i, &ar71xx_pci_irq_chip, 
    86                                          handle_level_irq); 
    87         } 
    88  
    89         set_irq_chained_handler(AR71XX_CPU_IRQ_IP2, ar71xx_pci_irq_handler); 
    90 } 
    91  
    92 static void ar724x_pci_irq_handler(unsigned int irq, struct irq_desc *desc) 
    93 { 
    94         u32 pending; 
    95  
    96         pending = ar724x_pci_rr(AR724X_PCI_REG_INT_STATUS) & 
    97                   ar724x_pci_rr(AR724X_PCI_REG_INT_MASK); 
    98  
    99         if (pending & AR724X_PCI_INT_DEV0) 
    100                 generic_handle_irq(AR71XX_PCI_IRQ_DEV0); 
    101  
    102         else 
    103                 spurious_interrupt(); 
    104 } 
    105  
    106 static void ar724x_pci_irq_unmask(unsigned int irq) 
    107 { 
    108         switch (irq) { 
    109         case AR71XX_PCI_IRQ_DEV0: 
    110                 irq -= AR71XX_PCI_IRQ_BASE; 
    111                 ar724x_pci_wr(AR724X_PCI_REG_INT_MASK, 
    112                               ar724x_pci_rr(AR724X_PCI_REG_INT_MASK) | 
    113                                             AR724X_PCI_INT_DEV0); 
    114                 /* flush write */ 
    115                 ar724x_pci_rr(AR724X_PCI_REG_INT_MASK); 
    116         } 
    117 } 
    118  
    119 static void ar724x_pci_irq_mask(unsigned int irq) 
    120 { 
    121         switch (irq) { 
    122         case AR71XX_PCI_IRQ_DEV0: 
    123                 irq -= AR71XX_PCI_IRQ_BASE; 
    124                 ar724x_pci_wr(AR724X_PCI_REG_INT_MASK, 
    125                               ar724x_pci_rr(AR724X_PCI_REG_INT_MASK) & 
    126                                             ~AR724X_PCI_INT_DEV0); 
    127                 /* flush write */ 
    128                 ar724x_pci_rr(AR724X_PCI_REG_INT_MASK); 
    129  
    130                 ar724x_pci_wr(AR724X_PCI_REG_INT_STATUS, 
    131                               ar724x_pci_rr(AR724X_PCI_REG_INT_STATUS) | 
    132                                             AR724X_PCI_INT_DEV0); 
    133                 /* flush write */ 
    134                 ar724x_pci_rr(AR724X_PCI_REG_INT_STATUS); 
    135         } 
    136 } 
    137  
    138 static struct irq_chip ar724x_pci_irq_chip = { 
    139         .name           = "AR724X PCI ", 
    140         .mask           = ar724x_pci_irq_mask, 
    141         .unmask         = ar724x_pci_irq_unmask, 
    142         .mask_ack       = ar724x_pci_irq_mask, 
    143 }; 
    144  
    145 static void __init ar724x_pci_irq_init(void) 
    146 { 
    147         u32 t; 
    148         int i; 
    149  
    150         t = ar71xx_reset_rr(AR724X_RESET_REG_RESET_MODULE); 
    151         if (t & (AR724X_RESET_PCIE | AR724X_RESET_PCIE_PHY | 
    152                  AR724X_RESET_PCIE_PHY_SERIAL)) { 
    153                 return; 
    154         } 
    155  
    156         ar724x_pci_wr(AR724X_PCI_REG_INT_MASK, 0); 
    157         ar724x_pci_wr(AR724X_PCI_REG_INT_STATUS, 0); 
    158  
    159         for (i = AR71XX_PCI_IRQ_BASE; 
    160              i < AR71XX_PCI_IRQ_BASE + AR71XX_PCI_IRQ_COUNT; i++) { 
    161                 irq_desc[i].status = IRQ_DISABLED; 
    162                 set_irq_chip_and_handler(i, &ar724x_pci_irq_chip, 
    163                                          handle_level_irq); 
    164         } 
    165  
    166         set_irq_chained_handler(AR71XX_CPU_IRQ_IP2, ar724x_pci_irq_handler); 
    167 } 
    168 #else 
    169 static inline void ar71xx_pci_irq_init(void) {}; 
    170 static inline void ar724x_pci_irq_init(void) {}; 
    171 #endif /* CONFIG_PCI */ 
    172  
    17324static void ar71xx_gpio_irq_dispatch(void) 
    17425{ 
     
    387238        cp0_perfcount_irq = AR71XX_MISC_IRQ_PERFC; 
    388239 
    389         switch (ar71xx_soc) { 
    390         case AR71XX_SOC_AR7130: 
    391         case AR71XX_SOC_AR7141: 
    392         case AR71XX_SOC_AR7161: 
    393                 ar71xx_pci_irq_init(); 
    394                 break; 
    395         case AR71XX_SOC_AR7240: 
    396                 ar724x_pci_irq_init(); 
    397                 break; 
    398         default: 
    399                 break; 
    400         } 
    401  
    402240        ar71xx_gpio_irq_init(); 
    403241} 
  • trunk/target/linux/ar71xx/files/arch/mips/pci/pci-ar71xx.c

    r17807 r20281  
    1818#include <linux/pci.h> 
    1919#include <linux/pci_regs.h> 
     20#include <linux/interrupt.h> 
    2021 
    2122#include <asm/mach-ar71xx/ar71xx.h> 
     
    301302}; 
    302303 
     304static void ar71xx_pci_irq_handler(unsigned int irq, struct irq_desc *desc) 
     305{ 
     306        u32 pending; 
     307 
     308        pending = ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_STATUS) & 
     309                  ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE); 
     310 
     311        if (pending & PCI_INT_DEV0) 
     312                generic_handle_irq(AR71XX_PCI_IRQ_DEV0); 
     313 
     314        else if (pending & PCI_INT_DEV1) 
     315                generic_handle_irq(AR71XX_PCI_IRQ_DEV1); 
     316 
     317        else if (pending & PCI_INT_DEV2) 
     318                generic_handle_irq(AR71XX_PCI_IRQ_DEV2); 
     319 
     320        else if (pending & PCI_INT_CORE) 
     321                generic_handle_irq(AR71XX_PCI_IRQ_CORE); 
     322 
     323        else 
     324                spurious_interrupt(); 
     325} 
     326 
     327static void ar71xx_pci_irq_unmask(unsigned int irq) 
     328{ 
     329        irq -= AR71XX_PCI_IRQ_BASE; 
     330        ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_ENABLE, 
     331                ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE) | (1 << irq)); 
     332 
     333        /* flush write */ 
     334        ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE); 
     335} 
     336 
     337static void ar71xx_pci_irq_mask(unsigned int irq) 
     338{ 
     339        irq -= AR71XX_PCI_IRQ_BASE; 
     340        ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_ENABLE, 
     341                ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE) & ~(1 << irq)); 
     342 
     343        /* flush write */ 
     344        ar71xx_reset_rr(AR71XX_RESET_REG_PCI_INT_ENABLE); 
     345} 
     346 
     347static struct irq_chip ar71xx_pci_irq_chip = { 
     348        .name           = "AR71XX PCI ", 
     349        .mask           = ar71xx_pci_irq_mask, 
     350        .unmask         = ar71xx_pci_irq_unmask, 
     351        .mask_ack       = ar71xx_pci_irq_mask, 
     352}; 
     353 
     354static void __init ar71xx_pci_irq_init(void) 
     355{ 
     356        int i; 
     357 
     358        ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_ENABLE, 0); 
     359        ar71xx_reset_wr(AR71XX_RESET_REG_PCI_INT_STATUS, 0); 
     360 
     361        for (i = AR71XX_PCI_IRQ_BASE; 
     362             i < AR71XX_PCI_IRQ_BASE + AR71XX_PCI_IRQ_COUNT; i++) { 
     363                irq_desc[i].status = IRQ_DISABLED; 
     364                set_irq_chip_and_handler(i, &ar71xx_pci_irq_chip, 
     365                                         handle_level_irq); 
     366        } 
     367 
     368        set_irq_chained_handler(AR71XX_CPU_IRQ_IP2, ar71xx_pci_irq_handler); 
     369} 
     370 
    303371int __init ar71xx_pcibios_init(void) 
    304372{ 
     
    327395 
    328396        ar71xx_pci_fixup_enable = 1; 
     397        ar71xx_pci_irq_init(); 
    329398        register_pci_controller(&ar71xx_pci_controller); 
    330399 
  • trunk/target/linux/ar71xx/files/arch/mips/pci/pci-ar724x.c

    r18860 r20281  
    22 *  Atheros AR724x PCI host controller driver 
    33 * 
    4  *  Copyright (C) 2009 Gabor Juhos <juhosg@openwrt.org> 
     4 *  Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org> 
    55 * 
    66 *  Parts of this file are based on Atheros' 2.6.15 BSP 
     
    1717#include <linux/pci.h> 
    1818#include <linux/pci_regs.h> 
     19#include <linux/interrupt.h> 
    1920 
    2021#include <asm/mach-ar71xx/ar71xx.h> 
     
    247248} 
    248249 
     250static void ar724x_pci_irq_handler(unsigned int irq, struct irq_desc *desc) 
     251{ 
     252        u32 pending; 
     253 
     254        pending = ar724x_pci_rr(AR724X_PCI_REG_INT_STATUS) & 
     255                  ar724x_pci_rr(AR724X_PCI_REG_INT_MASK); 
     256 
     257        if (pending & AR724X_PCI_INT_DEV0) 
     258                generic_handle_irq(AR71XX_PCI_IRQ_DEV0); 
     259 
     260        else 
     261                spurious_interrupt(); 
     262} 
     263 
     264static void ar724x_pci_irq_unmask(unsigned int irq) 
     265{ 
     266        switch (irq) { 
     267        case AR71XX_PCI_IRQ_DEV0: 
     268                irq -= AR71XX_PCI_IRQ_BASE; 
     269                ar724x_pci_wr(AR724X_PCI_REG_INT_MASK, 
     270                              ar724x_pci_rr(AR724X_PCI_REG_INT_MASK) | 
     271                                            AR724X_PCI_INT_DEV0); 
     272                /* flush write */ 
     273                ar724x_pci_rr(AR724X_PCI_REG_INT_MASK); 
     274        } 
     275} 
     276 
     277static void ar724x_pci_irq_mask(unsigned int irq) 
     278{ 
     279        switch (irq) { 
     280        case AR71XX_PCI_IRQ_DEV0: 
     281                irq -= AR71XX_PCI_IRQ_BASE; 
     282                ar724x_pci_wr(AR724X_PCI_REG_INT_MASK, 
     283                              ar724x_pci_rr(AR724X_PCI_REG_INT_MASK) & 
     284                                            ~AR724X_PCI_INT_DEV0); 
     285                /* flush write */ 
     286                ar724x_pci_rr(AR724X_PCI_REG_INT_MASK); 
     287 
     288                ar724x_pci_wr(AR724X_PCI_REG_INT_STATUS, 
     289                              ar724x_pci_rr(AR724X_PCI_REG_INT_STATUS) | 
     290                                            AR724X_PCI_INT_DEV0); 
     291                /* flush write */ 
     292                ar724x_pci_rr(AR724X_PCI_REG_INT_STATUS); 
     293        } 
     294} 
     295 
     296static struct irq_chip ar724x_pci_irq_chip = { 
     297        .name           = "AR724X PCI ", 
     298        .mask           = ar724x_pci_irq_mask, 
     299        .unmask         = ar724x_pci_irq_unmask, 
     300        .mask_ack       = ar724x_pci_irq_mask, 
     301}; 
     302 
     303static void __init ar724x_pci_irq_init(void) 
     304{ 
     305        u32 t; 
     306        int i; 
     307 
     308        t = ar71xx_reset_rr(AR724X_RESET_REG_RESET_MODULE); 
     309        if (t & (AR724X_RESET_PCIE | AR724X_RESET_PCIE_PHY | 
     310                 AR724X_RESET_PCIE_PHY_SERIAL)) { 
     311                return; 
     312        } 
     313 
     314        ar724x_pci_wr(AR724X_PCI_REG_INT_MASK, 0); 
     315        ar724x_pci_wr(AR724X_PCI_REG_INT_STATUS, 0); 
     316 
     317        for (i = AR71XX_PCI_IRQ_BASE; 
     318             i < AR71XX_PCI_IRQ_BASE + AR71XX_PCI_IRQ_COUNT; i++) { 
     319                irq_desc[i].status = IRQ_DISABLED; 
     320                set_irq_chip_and_handler(i, &ar724x_pci_irq_chip, 
     321                                         handle_level_irq); 
     322        } 
     323 
     324        set_irq_chained_handler(AR71XX_CPU_IRQ_IP2, ar724x_pci_irq_handler); 
     325} 
     326 
    249327int __init ar724x_pcibios_init(void) 
    250328{ 
     
    263341 
    264342        ar724x_pci_fixup_enable = 1; 
     343        ar724x_pci_irq_init(); 
    265344        register_pci_controller(&ar724x_pci_controller); 
    266345 
Note: See TracChangeset for help on using the changeset viewer.