← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to arch/tile/kernel/irq.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/tile/kernel/irq.c
176
176
EXPORT_SYMBOL(disable_percpu_irq);
177
177
 
178
178
/* Mask an interrupt. */
179
 
static void tile_irq_chip_mask(unsigned int irq)
 
179
static void tile_irq_chip_mask(struct irq_data *d)
180
180
{
181
 
        mask_irqs(1UL << irq);
 
181
        mask_irqs(1UL << d->irq);
182
182
}
183
183
 
184
184
/* Unmask an interrupt. */
185
 
static void tile_irq_chip_unmask(unsigned int irq)
 
185
static void tile_irq_chip_unmask(struct irq_data *d)
186
186
{
187
 
        unmask_irqs(1UL << irq);
 
187
        unmask_irqs(1UL << d->irq);
188
188
}
189
189
 
190
190
/*
191
191
 * Clear an interrupt before processing it so that any new assertions
192
192
 * will trigger another irq.
193
193
 */
194
 
static void tile_irq_chip_ack(unsigned int irq)
 
194
static void tile_irq_chip_ack(struct irq_data *d)
195
195
{
196
 
        if ((unsigned long)get_irq_chip_data(irq) != IS_HW_CLEARED)
197
 
                clear_irqs(1UL << irq);
 
196
        if ((unsigned long)irq_data_get_irq_chip_data(d) != IS_HW_CLEARED)
 
197
                clear_irqs(1UL << d->irq);
198
198
}
199
199
 
200
200
/*
201
201
 * For per-cpu interrupts, we need to avoid unmasking any interrupts
202
202
 * that we disabled via disable_percpu_irq().
203
203
 */
204
 
static void tile_irq_chip_eoi(unsigned int irq)
 
204
static void tile_irq_chip_eoi(struct irq_data *d)
205
205
{
206
 
        if (!(__get_cpu_var(irq_disable_mask) & (1UL << irq)))
207
 
                unmask_irqs(1UL << irq);
 
206
        if (!(__get_cpu_var(irq_disable_mask) & (1UL << d->irq)))
 
207
                unmask_irqs(1UL << d->irq);
208
208
}
209
209
 
210
210
static struct irq_chip tile_irq_chip = {
211
211
        .name = "tile_irq_chip",
212
 
        .ack = tile_irq_chip_ack,
213
 
        .eoi = tile_irq_chip_eoi,
214
 
        .mask = tile_irq_chip_mask,
215
 
        .unmask = tile_irq_chip_unmask,
 
212
        .irq_ack = tile_irq_chip_ack,
 
213
        .irq_eoi = tile_irq_chip_eoi,
 
214
        .irq_mask = tile_irq_chip_mask,
 
215
        .irq_unmask = tile_irq_chip_unmask,
216
216
};
217
217
 
218
218
void __init init_IRQ(void)
241
241
        irq_flow_handler_t handle = handle_level_irq;
242
242
        if (tile_irq_type == TILE_IRQ_PERCPU)
243
243
                handle = handle_percpu_irq;
244
 
        set_irq_chip_and_handler(irq, &tile_irq_chip, handle);
 
244
        irq_set_chip_and_handler(irq, &tile_irq_chip, handle);
245
245
 
246
246
        /*
247
247
         * Flag interrupts that are hardware-cleared so that ack()
248
248
         * won't clear them.
249
249
         */
250
250
        if (tile_irq_type == TILE_IRQ_HW_CLEAR)
251
 
                set_irq_chip_data(irq, (void *)IS_HW_CLEARED);
 
251
                irq_set_chip_data(irq, (void *)IS_HW_CLEARED);
252
252
}
253
253
EXPORT_SYMBOL(tile_irq_activate);
254
254
 
262
262
 * Generic, controller-independent functions:
263
263
 */
264
264
 
265
 
int show_interrupts(struct seq_file *p, void *v)
266
 
{
267
 
        int i = *(loff_t *) v, j;
268
 
        struct irqaction *action;
269
 
        unsigned long flags;
270
 
 
271
 
        if (i == 0) {
272
 
                seq_printf(p, "           ");
273
 
                for (j = 0; j < NR_CPUS; j++)
274
 
                        if (cpu_online(j))
275
 
                                seq_printf(p, "CPU%-8d", j);
276
 
                seq_putc(p, '\n');
277
 
        }
278
 
 
279
 
        if (i < NR_IRQS) {
280
 
                raw_spin_lock_irqsave(&irq_desc[i].lock, flags);
281
 
                action = irq_desc[i].action;
282
 
                if (!action)
283
 
                        goto skip;
284
 
                seq_printf(p, "%3d: ", i);
285
 
#ifndef CONFIG_SMP
286
 
                seq_printf(p, "%10u ", kstat_irqs(i));
287
 
#else
288
 
                for_each_online_cpu(j)
289
 
                        seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
290
 
#endif
291
 
                seq_printf(p, " %14s", irq_desc[i].chip->name);
292
 
                seq_printf(p, "  %s", action->name);
293
 
 
294
 
                for (action = action->next; action; action = action->next)
295
 
                        seq_printf(p, ", %s", action->name);
296
 
 
297
 
                seq_putc(p, '\n');
298
 
skip:
299
 
                raw_spin_unlock_irqrestore(&irq_desc[i].lock, flags);
300
 
        }
301
 
        return 0;
302
 
}
303
 
 
304
265
#if CHIP_HAS_IPI()
305
266
int create_irq(void)
306
267
{