source: trunk/target/linux/omap24xx/patches-3.1/252-cbus-retu-tahvo-ack-fix.patch @ 29237

Last change on this file since 29237 was 29237, checked in by mb, 5 years ago

omap24xx: Fix cbus nested IRQ acking

File size: 3.9 KB
  • drivers/cbus/retu.c

    old new struct retu { 
    5353 
    5454        int                     irq; 
    5555 
    56         int                     ack; 
    57         bool                    ack_pending; 
    58  
    5956        int                     mask; 
    6057        bool                    mask_pending; 
    6158 
    static irqreturn_t retu_irq_handler(int 
    191188        mutex_lock(&retu->mutex); 
    192189        idr = __retu_read_reg(retu, RETU_REG_IDR); 
    193190        imr = __retu_read_reg(retu, RETU_REG_IMR); 
     191        idr &= ~imr; 
     192        __retu_write_reg(retu, RETU_REG_IDR, idr); 
    194193        mutex_unlock(&retu->mutex); 
    195194 
    196         idr &= ~imr; 
    197195        if (!idr) { 
    198196                dev_vdbg(retu->dev, "No IRQ, spurious?\n"); 
    199197                return IRQ_NONE; 
    static void retu_irq_unmask(struct irq_d 
    232230 
    233231} 
    234232 
    235 static void retu_irq_ack(struct irq_data *data) 
    236 { 
    237         struct retu             *retu = irq_data_get_irq_chip_data(data); 
    238         int                     irq = data->irq; 
    239  
    240         retu->ack |= (1 << (irq - retu->irq_base)); 
    241         retu->ack_pending = true; 
    242 } 
    243  
    244233static void retu_bus_lock(struct irq_data *data) 
    245234{ 
    246235        struct retu             *retu = irq_data_get_irq_chip_data(data); 
    static void retu_bus_sync_unlock(struct 
    257246                retu->mask_pending = false; 
    258247        } 
    259248 
    260         if (retu->ack_pending) { 
    261                 __retu_write_reg(retu, RETU_REG_IDR, retu->ack); 
    262                 retu->ack_pending = false; 
    263         } 
    264  
    265249        mutex_unlock(&retu->mutex); 
    266250} 
    267251 
    static struct irq_chip retu_irq_chip = { 
    271255        .irq_bus_sync_unlock    = retu_bus_sync_unlock, 
    272256        .irq_mask               = retu_irq_mask, 
    273257        .irq_unmask             = retu_irq_unmask, 
    274         .irq_ack                = retu_irq_ack, 
    275258}; 
    276259 
    277260static inline void retu_irq_setup(int irq) 
    static void retu_irq_init(struct retu *r 
    291274 
    292275        for (irq = base; irq < end; irq++) { 
    293276                irq_set_chip_data(irq, retu); 
    294                 irq_set_chip_and_handler(irq, &retu_irq_chip, 
    295                                 handle_simple_irq); 
     277                irq_set_chip(irq, &retu_irq_chip); 
    296278                irq_set_nested_thread(irq, 1); 
    297279                retu_irq_setup(irq); 
    298280        } 
  • drivers/cbus/tahvo.c

    old new struct tahvo { 
    4848        int             irq_end; 
    4949        int             irq; 
    5050 
    51         int             ack; 
    5251        int             mask; 
    5352 
    5453        unsigned int    mask_pending:1; 
    55         unsigned int    ack_pending:1; 
    5654        unsigned int    is_betty:1; 
    5755}; 
    5856 
    static irqreturn_t tahvo_irq_handler(int 
    138136        u16                     id; 
    139137        u16                     im; 
    140138 
     139        mutex_lock(&tahvo->mutex); 
    141140        id = __tahvo_read_reg(tahvo, TAHVO_REG_IDR); 
    142141        im = __tahvo_read_reg(tahvo, TAHVO_REG_IMR); 
    143142        id &= ~im; 
     143        __tahvo_write_reg(tahvo, TAHVO_REG_IDR, id); 
     144        mutex_unlock(&tahvo->mutex); 
    144145 
    145146        if (!id) { 
    146147                dev_vdbg(tahvo->dev, "No IRQ, spurious ?\n"); 
    static void tahvo_irq_bus_sync_unlock(st 
    177178                tahvo->mask_pending = false; 
    178179        } 
    179180 
    180         if (tahvo->ack_pending) { 
    181                 __tahvo_write_reg(tahvo, TAHVO_REG_IDR, tahvo->ack); 
    182                 tahvo->ack_pending = false; 
    183         } 
    184  
    185181        mutex_unlock(&tahvo->mutex); 
    186182} 
    187183 
    static void tahvo_irq_unmask(struct irq_ 
    203199        tahvo->mask_pending = true; 
    204200} 
    205201 
    206 static void tahvo_irq_ack(struct irq_data *data) 
    207 { 
    208         struct tahvo            *tahvo = irq_data_get_irq_chip_data(data); 
    209         int                     irq = data->irq; 
    210  
    211         tahvo->ack |= (1 << (irq - tahvo->irq_base)); 
    212         tahvo->ack_pending = true; 
    213 } 
    214  
    215202static struct irq_chip tahvo_irq_chip = { 
    216203        .name                   = "tahvo", 
    217204        .irq_bus_lock           = tahvo_irq_bus_lock, 
    218205        .irq_bus_sync_unlock    = tahvo_irq_bus_sync_unlock, 
    219206        .irq_mask               = tahvo_irq_mask, 
    220207        .irq_unmask             = tahvo_irq_unmask, 
    221         .irq_ack                = tahvo_irq_ack, 
    222208}; 
    223209 
    224210static inline void tahvo_irq_setup(int irq) 
    static void tahvo_irq_init(struct tahvo 
    238224 
    239225        for (irq = base; irq < end; irq++) { 
    240226                irq_set_chip_data(irq, tahvo); 
    241                 irq_set_chip_and_handler(irq, &tahvo_irq_chip, 
    242                                 handle_simple_irq); 
     227                irq_set_chip(irq, &tahvo_irq_chip); 
    243228                irq_set_nested_thread(irq, 1); 
    244229                tahvo_irq_setup(irq); 
    245230        } 
Note: See TracBrowser for help on using the repository browser.