Esempio n. 1
0
static unsigned int sun4c_build_device_irq(struct platform_device *op,
					   unsigned int real_irq)
{
	 unsigned int irq;

	if (real_irq >= 16) {
		prom_printf("Bogus sun4c IRQ %u\n", real_irq);
		prom_halt();
	}

	irq = irq_alloc(real_irq, real_irq);
	if (irq) {
		unsigned long mask = 0UL;

		switch (real_irq) {
		case 1:
			mask = SUN4C_INT_E1;
			break;
		case 8:
			mask = SUN4C_INT_E8;
			break;
		case 10:
			mask = SUN4C_INT_E10;
			break;
		case 14:
			mask = SUN4C_INT_E14;
			break;
		default:
			/* All the rest are either always enabled,
			 * or are for signalling software interrupts.
			 */
			break;
		}
		irq_set_chip_and_handler_name(irq, &sun4c_irq,
		                              handle_level_irq, "level");
		irq_set_chip_data(irq, (void *)mask);
	}
	return irq;
}
Esempio n. 2
0
static int sparc64_setup_msi_irq(unsigned int *irq_p,
				 struct pci_dev *pdev,
				 struct msi_desc *entry)
{
	struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
	const struct sparc64_msiq_ops *ops = pbm->msi_ops;
	struct msi_msg msg;
	int msi, err;
	u32 msiqid;

	*irq_p = irq_alloc(0, 0);
	err = -ENOMEM;
	if (!*irq_p)
		goto out_err;

	irq_set_chip_and_handler_name(*irq_p, &msi_irq, handle_simple_irq,
				      "MSI");

	err = alloc_msi(pbm);
	if (unlikely(err < 0))
		goto out_irq_free;

	msi = err;

	msiqid = pick_msiq(pbm);

	err = ops->msi_setup(pbm, msiqid, msi,
			     (entry->msi_attrib.is_64 ? 1 : 0));
	if (err)
		goto out_msi_free;

	pbm->msi_irq_table[msi - pbm->msi_first] = *irq_p;

	if (entry->msi_attrib.is_64) {
		msg.address_hi = pbm->msi64_start >> 32;
		msg.address_lo = pbm->msi64_start & 0xffffffff;
	} else {
static unsigned int sun4m_build_device_irq(struct platform_device *op,
        unsigned int real_irq)
{
    struct sun4m_handler_data *handler_data;
    unsigned int irq;
    unsigned int pil;

    if (real_irq >= OBP_INT_LEVEL_VME) {
        prom_printf("Bogus sun4m IRQ %u\n", real_irq);
        prom_halt();
    }
    pil = (real_irq & 0xf);
    irq = irq_alloc(real_irq, pil);

    if (irq == 0)
        goto out;

    handler_data = irq_get_handler_data(irq);
    if (unlikely(handler_data))
        goto out;

    handler_data = kzalloc(sizeof(struct sun4m_handler_data), GFP_ATOMIC);
    if (unlikely(!handler_data)) {
        prom_printf("IRQ: kzalloc(sun4m_handler_data) failed.\n");
        prom_halt();
    }

    handler_data->mask = sun4m_imask[real_irq];
    handler_data->percpu = real_irq < OBP_INT_LEVEL_ONBOARD;
    irq_set_chip_and_handler_name(irq, &sun4m_irq,
                                  handle_level_irq, "level");
    irq_set_handler_data(irq, handler_data);

out:
    return irq;
}