Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1919417
  • 博文数量: 376
  • 博客积分: 2147
  • 博客等级: 大尉
  • 技术积分: 3642
  • 用 户 组: 普通用户
  • 注册时间: 2012-02-06 10:47
文章分类

全部博文(376)

文章存档

2019年(3)

2017年(28)

2016年(15)

2015年(17)

2014年(182)

2013年(16)

2012年(115)

我的朋友

分类: 嵌入式

2013-03-21 17:34:24

//drivers/net/gianfar.c
static int gfar_parse_group(struct device_node *np,
        struct gfar_private *priv, const char *model)
{
    u32 *queue_mask;
#ifdef CONFIG_GFAR_SW_PKT_STEERING
    int i;
    int cpus = num_online_cpus();
#endif
    priv->gfargrp[priv->num_grps].regs = of_iomap(np, 0);
    if (!priv->gfargrp[priv->num_grps].regs)
        return -ENOMEM;

    priv->gfargrp[priv->num_grps].interruptTransmit =
            irq_of_parse_and_map(np, 0);//解释与映射发送中断

    /* If we aren't the FEC we have multiple interrupts */
    if (model && strcasecmp(model, "FEC")) {
        priv->gfargrp[priv->num_grps].interruptReceive =
            irq_of_parse_and_map(np, 1);
        priv->gfargrp[priv->num_grps].interruptError =
            irq_of_parse_and_map(np,2);
        if (priv->gfargrp[priv->num_grps].interruptTransmit < 0 ||
            priv->gfargrp[priv->num_grps].interruptReceive < 0 ||
            priv->gfargrp[priv->num_grps].interruptError < 0) {
            return -EINVAL;
        }
    }

    priv->gfargrp[priv->num_grps].grp_id = priv->num_grps;
    priv->gfargrp[priv->num_grps].priv = priv;
    spin_lock_init(&priv->gfargrp[priv->num_grps].grplock);
    if(priv->mode == MQ_MG_MODE) {
        queue_mask = (u32 *)of_get_property(np,
                    "rx-bit-map", NULL);
        priv->gfargrp[priv->num_grps].rx_bit_map =
            queue_mask ?  *queue_mask :(DEFAULT_MAPPING >> priv->num_grps);
        queue_mask = (u32 *)of_get_property(np,
                    "tx-bit-map", NULL);
        priv->gfargrp[priv->num_grps].tx_bit_map =
            queue_mask ? *queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
    } else {
        priv->gfargrp[priv->num_grps].rx_bit_map = 0xFF;
        priv->gfargrp[priv->num_grps].tx_bit_map = 0xFF;
    }
#ifdef CONFIG_GFAR_SW_PKT_STEERING
    if (priv->sps) {
        /* register msg unit for virtual tx interrupt for each cpu */
        for (i = 0; i < cpus; i++) { /* for each cpu */
            priv->gfargrp[priv->num_grps].msg_virtual_tx[i]
                = fsl_get_msg_unit();
            if (IS_ERR
            (priv->gfargrp[priv->num_grps].msg_virtual_tx[i])) {
                priv->sps = 0;
                printk(KERN_WARNING
                "%s: unable to allocate msg interrupt for pkt"
                "steering, error = %ld!\n", __func__,
                PTR_ERR(priv->gfargrp[priv->num_grps].
                msg_virtual_tx[i]));
            }
        }
    }
#endif
    priv->num_grps++;

    return 0;
}

//arch/powerpc/kernel/irq.c
unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
{
    struct of_irq oirq;

    if (of_irq_map_one(dev, index, &oirq))
        return NO_IRQ;

    return irq_create_of_mapping(oirq.controller, oirq.specifier,
                     oirq.size);
}


//arch/powerpc/kernel/prom_parse.c
int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
{
    struct device_node *p;
    const u32 *intspec, *tmp, *addr;
    u32 intsize, intlen;
    int res = -EINVAL;

    DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);//iindex对发送,接收,错误分别是0,1,2.对于发送中断打印of_irq_map_one: dev=/soc@ffe00000/ethernet@b1000/queue-group@0, index=0

    /* OldWorld mac stuff is "special", handle out of line */
    if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)//假
        return of_irq_map_oldworld(device, index, out_irq);

    /* Get the interrupts property */
    intspec = of_get_property(device, "interrupts", &intlen);//intspec指向6个元素的数组,intspec[0]=29,intspec[1]=2,intspec[2]=30,intspec[3]=2,intspec[4]=34,intspec[5]=2,
    if (intspec == NULL)
        return -EINVAL;
    intlen /= sizeof(u32);

    /* Get the reg property (if any) */
    addr = of_get_property(device, "reg", NULL);

    /* Look for the interrupt parent. */
    p = of_irq_find_parent(device);//查找设备中断最终父节点,其实就是pic节点  ,在dts文件中     mpic: pic@40000 {  interrupt-controller; #address-cells = <0>; #interrupt-cells = <2>;  reg = <0x40000 0x40000>; compatible = "chrp,open-pic";  device_type = "open-pic"; };

    if (p == NULL)
        return -EINVAL;

    /* Get size of interrupt specifier */
    tmp = of_get_property(p, "#interrupt-cells", NULL);
    if (tmp == NULL)
        goto out;
    intsize = *tmp;//intsize为2

    DBG(" intsize=%d intlen=%d\n", intsize, intlen);// intsize=2 intlen=6

    /* Check index */
    if ((index + 1) * intsize > intlen)//对于发送,接收,错误都是假
        goto out;

    /* Get new specifier and map it */
    res = of_irq_map_raw(p, intspec + index * intsize, intsize,
                 addr, out_irq);
out:
    of_node_put(p);
    return res;
}

int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize,
        const u32 *addr, struct of_irq *out_irq)
{
    struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL;
    const u32 *tmp, *imap, *imask;
    u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
    int imaplen, match, i;

    DBG("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n",
        parent->full_name, intspec[0], intspec[1], ointsize);//对于发送中断of_irq_map_raw: par=/soc@ffe00000/pic@40000,intspec=[0x0000001d 0x00000002...],ointsize=2

    ipar = of_node_get(parent);

    /* First get the #interrupt-cells property of the current cursor
     * that tells us how to interpret the passed-in intspec. If there
     * is none, we are nice and just walk up the tree
     */
    do {
        tmp = of_get_property(ipar, "#interrupt-cells", NULL);//因为ipar已经是pic,所以有此属性
        if (tmp != NULL) {
            intsize = *tmp;
            break;
        }
        tnode = ipar;
        ipar = of_irq_find_parent(ipar);
        of_node_put(tnode);
    } while (ipar);
    if (ipar == NULL) {
        DBG(" -> no parent found !\n");
        goto fail;
    }

    DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize);//of_irq_map_raw: ipar=/soc@ffe00000/pic@40000, size=2

    if (ointsize != intsize)//假
        return -EINVAL;

    /* Look for this #address-cells. We have to implement the old linux
     * trick of looking for the parent here as some device-trees rely on it
     */
    old = of_node_get(ipar);
    do {
        tmp = of_get_property(old, "#address-cells", NULL);//有此属性值为0,所以*tmp值为0
        tnode = of_get_parent(old);
        of_node_put(old);
        old = tnode;
    } while(old && tmp == NULL);
    of_node_put(old);
    old = NULL;
    addrsize = (tmp == NULL) ? 2 : *tmp;

    DBG(" -> addrsize=%d\n", addrsize);// -> addrsize=0

    /* Now start the actual "proper" walk of the interrupt tree */
    while (ipar != NULL) {
        /* Now check if cursor is an interrupt-controller and if it is
         * then we are done
         */
        if (of_get_property(ipar, "interrupt-controller", NULL) != //有此属性
                NULL) {
            DBG(" -> got it !\n");
            memcpy(out_irq->specifier, intspec,
                   intsize * sizeof(u32));//把中断向量和中断触发方式拷贝到specifier,对于发送其值分别为29,2,表示中断向量为29,高电平触发
            out_irq->size = intsize;
            out_irq->controller = ipar;
            of_node_put(old);
            return 0;
        }

        /* Now look for an interrupt-map */
        imap = of_get_property(ipar, "interrupt-map", &imaplen);
        /* No interrupt map, check for an interrupt parent */
        if (imap == NULL) {
            DBG(" -> no map, getting parent\n");
            newpar = of_irq_find_parent(ipar);
            goto skiplevel;
        }
        imaplen /= sizeof(u32);

        /* Look for a mask */
        imask = of_get_property(ipar, "interrupt-map-mask", NULL);

        /* If we were passed no "reg" property and we attempt to parse
         * an interrupt-map, then #address-cells must be 0.
         * Fail if it's not.
         */
        if (addr == NULL && addrsize != 0) {
            DBG(" -> no reg passed in when needed !\n");
            goto fail;
        }

        /* Parse interrupt-map */
        match = 0;
        while (imaplen > (addrsize + intsize + 1) && !match) {
            /* Compare specifiers */
            match = 1;
            for (i = 0; i < addrsize && match; ++i) {
                u32 mask = imask ? imask[i] : 0xffffffffu;
                match = ((addr[i] ^ imap[i]) & mask) == 0;
            }
            for (; i < (addrsize + intsize) && match; ++i) {
                u32 mask = imask ? imask[i] : 0xffffffffu;
                match =
                   ((intspec[i-addrsize] ^ imap[i]) & mask) == 0;
            }
            imap += addrsize + intsize;
            imaplen -= addrsize + intsize;

            DBG(" -> match=%d (imaplen=%d)\n", match, imaplen);

            /* Get the interrupt parent */
            if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
                newpar = of_node_get(of_irq_dflt_pic);
            else
                newpar = of_find_node_by_phandle((phandle)*imap);
            imap++;
            --imaplen;

            /* Check if not found */
            if (newpar == NULL) {
                DBG(" -> imap parent not found !\n");
                goto fail;
            }

            /* Get #interrupt-cells and #address-cells of new
             * parent
             */
            tmp = of_get_property(newpar, "#interrupt-cells", NULL);
            if (tmp == NULL) {
                DBG(" -> parent lacks #interrupt-cells !\n");
                goto fail;
            }
            newintsize = *tmp;
            tmp = of_get_property(newpar, "#address-cells", NULL);
            newaddrsize = (tmp == NULL) ? 0 : *tmp;

            DBG(" -> newintsize=%d, newaddrsize=%d\n",
                newintsize, newaddrsize);

            /* Check for malformed properties */
            if (imaplen < (newaddrsize + newintsize))
                goto fail;

            imap += newaddrsize + newintsize;
            imaplen -= newaddrsize + newintsize;

            DBG(" -> imaplen=%d\n", imaplen);
        }
        if (!match)
            goto fail;

        of_node_put(old);
        old = of_node_get(newpar);
        addrsize = newaddrsize;
        intsize = newintsize;
        intspec = imap - intsize;
        addr = intspec - addrsize;

    skiplevel:
        /* Iterate again with new parent */
        DBG(" -> new parent: %s\n", newpar ? newpar->full_name : "<>");
        of_node_put(ipar);
        ipar = newpar;
        newpar = NULL;
    }
 fail:
    of_node_put(ipar);
    of_node_put(old);
    of_node_put(newpar);

    return -EINVAL;
}

unsigned int irq_create_of_mapping(struct device_node *controller,
                   const u32 *intspec, unsigned int intsize)
{
    struct irq_host *host;
    irq_hw_number_t hwirq;
    unsigned int type = IRQ_TYPE_NONE;
    unsigned int virq;

    if (controller == NULL)
        host = irq_default_host;
    else
        host = irq_find_host(controller);//查找得到就是mpic->irqhost
    if (host == NULL) {
        printk(KERN_WARNING "irq: no irq host found for %s !\n",
               controller->full_name);
        return NO_IRQ;
    }

    /* If host has no translation, then we assume interrupt line */
    if (host->ops->xlate == NULL)
        hwirq = intspec[0];
    else {
        if (host->ops->xlate(host, controller, intspec, intsize,
                     &hwirq, &type))//调用mpic_host_ops中的函数mpic_host_xlate
            return NO_IRQ;
    }

    /* Create mapping */
    virq = irq_create_mapping(host, hwirq);
    if (virq == NO_IRQ)
        return virq;

    /* Set type if specified and different than the current one */
    if (type != IRQ_TYPE_NONE &&
        type != (irq_to_desc(virq)->status & IRQF_TRIGGER_MASK))
        set_irq_type(virq, type);
    return virq;
}

//arch/powerpc/sysdev/mpic.c
static int mpic_host_xlate(struct irq_host *h, struct device_node *ct,
               const u32 *intspec, unsigned int intsize,
               irq_hw_number_t *out_hwirq, unsigned int *out_flags)

{
    static unsigned char map_mpic_senses[4] = {
        IRQ_TYPE_EDGE_RISING,
        IRQ_TYPE_LEVEL_LOW,
        IRQ_TYPE_LEVEL_HIGH,
        IRQ_TYPE_EDGE_FALLING,
    };

    *out_hwirq = intspec[0];//中断向量号
    if (intsize > 1) {//intsize为2
        u32 mask = 0x3;

        /* Apple invented a new race of encoding on machines with
         * an HT APIC. They encode, among others, the index within
         * the HT APIC. We don't care about it here since thankfully,
         * it appears that they have the APIC already properly
         * configured, and thus our current fixup code that reads the
         * APIC config works fine. However, we still need to mask out
         * bits in the specifier to make sure we only get bit 0 which
         * is the level/edge bit (the only sense bit exposed by Apple),
         * as their bit 1 means something else.
         */
        if (machine_is(powermac))
            mask = 0x1;
        *out_flags = map_mpic_senses[intspec[1] & mask];//intspec[1]为2,所以*out_flags为4表示高电平触发
    } else
        *out_flags = IRQ_TYPE_NONE;

    DBG("mpic: xlate (%d cells: 0x%08x 0x%08x) to line 0x%lx sense 0x%x\n",
        intsize, intspec[0], intspec[1], *out_hwirq, *out_flags);//mpic: xlate (2 cells: 0x0000001d 0x00000002) to line 0x1d sense 0x4
    return 0;
}

unsigned int irq_create_mapping(struct irq_host *host,
                irq_hw_number_t hwirq)
{
    unsigned int virq, hint;

    pr_debug("irq: irq_create_mapping(0x%p, 0x%lx)\n", host, hwirq);

    /* Look for default host if nececssary */
    if (host == NULL)
        host = irq_default_host;
    if (host == NULL) {
        printk(KERN_WARNING "irq_create_mapping called for"
               " NULL host, hwirq=%lx\n", hwirq);
        WARN_ON(1);
        return NO_IRQ;
    }
    pr_debug("irq: -> using host @%p\n", host);

    /* Check if mapping already exist, if it does, call
     * host->ops->map() to update the flags
     */
    virq = irq_find_mapping(host, hwirq);//查找hwirq硬件IRQ号对应的虚拟IRQ号,因为么第一次所以找不到
    if (virq != NO_IRQ) {//第一次肯定找不到
        if (host->ops->remap)
            host->ops->remap(host, virq, hwirq);
        pr_debug("irq: -> existing mapping on virq %d\n", virq);
        return virq;
    }

    /* Get a virtual interrupt number */
    if (host->revmap_type == IRQ_HOST_MAP_LEGACY) {//false
        /* Handle legacy */
        virq = (unsigned int)hwirq;
        if (virq == 0 || virq >= NUM_ISA_INTERRUPTS)
            return NO_IRQ;
        return virq;
    } else {
        /* Allocate a virtual interrupt number */
        hint = hwirq % irq_virq_count;
        virq = irq_alloc_virt(host, 1, hint);//分配一个虚拟的virq
        if (virq == NO_IRQ) {
            pr_debug("irq: -> virq allocation failed\n");
            return NO_IRQ;
        }
    }

    if (irq_setup_virq(host, virq, hwirq))
        return NO_IRQ;

    printk(KERN_DEBUG "irq: irq %lu on host %s mapped to virtual irq %u\n",
        hwirq, host->of_node ? host->of_node->full_name : "null", virq);

    return virq;
}
unsigned int irq_find_mapping(struct irq_host *host,
                  irq_hw_number_t hwirq)
{
    unsigned int i;
    unsigned int hint = hwirq % irq_virq_count;//irq_virq_count为512,所以29%512=29

    /* Look for default host if nececssary */
    if (host == NULL)
        host = irq_default_host;
    if (host == NULL)
        return NO_IRQ;

    /* legacy -> bail early */
    if (host->revmap_type == IRQ_HOST_MAP_LEGACY)//false
        return hwirq;

    /* Slow path does a linear search of the map */
    if (hint < NUM_ISA_INTERRUPTS)//NUM_ISA_INTERRUPTS为16
        hint = NUM_ISA_INTERRUPTS;
    i = hint;
    do  {
        if (irq_map[i].host == host &&
            irq_map[i].hwirq == hwirq)//查找是否有hwirq
            return i;
        i++;
        if (i >= irq_virq_count)
            i = NUM_ISA_INTERRUPTS;
    } while(i != hint);
    return NO_IRQ;
}

unsigned int irq_alloc_virt(struct irq_host *host,
                unsigned int count,
                unsigned int hint)
{
    unsigned long flags;
    unsigned int i, j, found = NO_IRQ;

    if (count == 0 || count > (irq_virq_count - NUM_ISA_INTERRUPTS))
        return NO_IRQ;

    raw_spin_lock_irqsave(&irq_big_lock, flags);

    /* Use hint for 1 interrupt if any */
    if (count == 1 && hint >= NUM_ISA_INTERRUPTS &&
        hint < irq_virq_count && irq_map[hint].host == NULL) {//hint是否可以,第一次,所以查找成功
        found = hint;//虚拟irq等于hint
        goto hint_found;
    }

    /* Look for count consecutive numbers in the allocatable
     * (non-legacy) space
     */
    for (i = NUM_ISA_INTERRUPTS, j = 0; i < irq_virq_count; i++) {
        if (irq_map[i].host != NULL)
            j = 0;
        else
            j++;

        if (j == count) {
            found = i - count + 1;
            break;
        }
    }
    if (found == NO_IRQ) {
        raw_spin_unlock_irqrestore(&irq_big_lock, flags);
        return NO_IRQ;
    }
 hint_found:
    for (i = found; i < (found + count); i++) {
        irq_map[i].hwirq = host->inval_irq;
        smp_wmb();
        irq_map[i].host = host;//保存host
    }
    raw_spin_unlock_irqrestore(&irq_big_lock, flags);
    return found;
}

static int irq_setup_virq(struct irq_host *host, unsigned int virq,
                irq_hw_number_t hwirq)
{
    struct irq_desc *desc;

    desc = irq_to_desc_alloc_node(virq, 0);//分配给virq使用的desc
    if (!desc) {
        pr_debug("irq: -> allocating desc failed\n");
        goto error;
    }

    /* Clear IRQ_NOREQUEST flag */
    desc->status &= ~IRQ_NOREQUEST;

    /* map it */
    smp_wmb();
    irq_map[virq].hwirq = hwirq;//记录下来
    smp_mb();

    if (host->ops->map(host, virq, hwirq)) {//其实是调用mpic_host_ops中的mpic_host_map
        pr_debug("irq: -> mapping failed, freeing\n");
        goto error;
    }

    return 0;

error:
    irq_free_virt(virq, 1);
    return -1;
}

static int mpic_host_map(struct irq_host *h, unsigned int virq,
             irq_hw_number_t hw)
{
    struct mpic *mpic = h->host_data;
    struct irq_chip *chip;

    DBG("mpic: map virq %d, hwirq 0x%lx\n", virq, hw);

    if (hw == mpic->spurious_vec)
        return -EINVAL;
    if (mpic->protected && test_bit(hw, mpic->protected))
        return -EINVAL;

    else if (hw >= mpic->timer_vecs[0] && hw <= mpic->timer_vecs[3]) {
        WARN_ON(!(mpic->flags & MPIC_PRIMARY));

        DBG("mpic: mapping as timer\n");
        set_irq_chip_data(virq, mpic);
        set_irq_chip_and_handler(virq, &mpic->hc_tm,
                     handle_fasteoi_irq);
        return 0;
    }
#ifdef CONFIG_SMP
    else if (hw >= mpic->ipi_vecs[0]) {
        WARN_ON(!(mpic->flags & MPIC_PRIMARY));

        DBG("mpic: mapping as IPI\n");
        set_irq_chip_data(virq, mpic);
        set_irq_chip_and_handler(virq, &mpic->hc_ipi,
                     handle_percpu_irq);
        return 0;
    }
#endif /* CONFIG_SMP */

    if (hw >= mpic->irq_count)
        return -EINVAL;

    mpic_msi_reserve_hwirq(mpic, hw);

    /* Default chip */
    chip = &mpic->hc_irq;//其实就是mpic_irq_chip

#ifdef CONFIG_MPIC_U3_HT_IRQS
    /* Check for HT interrupts, override vecpri */
    if (mpic_is_ht_interrupt(mpic, hw))
        chip = &mpic->hc_ht_irq;
#endif /* CONFIG_MPIC_U3_HT_IRQS */

    DBG("mpic: mapping to irq chip @%p\n", chip);

    set_irq_chip_data(virq, mpic);//把mpic保存到virq对于的desc中
    set_irq_chip_and_handler(virq, chip, handle_fasteoi_irq);;//把chip,handle_fasteoi_irq保存到virq对于的desc中

    /* Set default irq type */
    set_irq_type(virq, IRQ_TYPE_NONE);

    return 0;
}

void
set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
             irq_flow_handler_t handle)
{
    set_irq_chip(irq, chip);//保存chip到irq对于的desc
    __set_irq_handler(irq, handle, 0, NULL);//保存handle到irq对于desc的 handle_irq
}

int set_irq_type(unsigned int irq, unsigned int type)
{
    struct irq_desc *desc = irq_to_desc(irq);
    unsigned long flags;
    int ret = -ENXIO;

    if (!desc) {
        printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
        return -ENODEV;
    }

    type &= IRQ_TYPE_SENSE_MASK;
    if (type == IRQ_TYPE_NONE)
        return 0;

    raw_spin_lock_irqsave(&desc->lock, flags);
    ret = __irq_set_trigger(desc, irq, type);
    raw_spin_unlock_irqrestore(&desc->lock, flags);
    return ret;
}


int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
        unsigned long flags)
{
    int ret;
    struct irq_chip *chip = desc->chip;

    if (!chip || !chip->set_type) {
        /*
         * IRQF_TRIGGER_* but the PIC does not support multiple
         * flow-types?
         */
        pr_debug("No set_type function for IRQ %d (%s)\n", irq,
                chip ? (chip->name ? : "unknown") : "unknown");
        return 0;
    }

    /* caller masked out all except trigger mode flags */
    ret = chip->set_type(irq, flags);//调用mpic_irq_chip的mpic_set_irq_type

    if (ret)
        pr_err("setting trigger mode %d for irq %u failed (%pF)\n",
                (int)flags, irq, chip->set_type);
    else {
        if (flags & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
            flags |= IRQ_LEVEL;
        /* note that IRQF_TRIGGER_MASK == IRQ_TYPE_SENSE_MASK */
        desc->status &= ~(IRQ_LEVEL | IRQ_TYPE_SENSE_MASK);
        desc->status |= flags;

        if (chip != desc->chip)
            irq_chip_set_defaults(desc->chip);
    }

    return ret;
}

int mpic_set_irq_type(unsigned int virq, unsigned int flow_type)
{
    struct mpic *mpic = mpic_from_irq(virq);
    unsigned int src = mpic_irq_to_hw(virq);
    struct irq_desc *desc = irq_to_desc(virq);
    unsigned int vecpri, vold, vnew;

    DBG("mpic: set_irq_type(mpic:@%p,virq:%d,src:0x%x,type:0x%x)\n",
        mpic, virq, src, flow_type);//打印mpic: set_irq_type(mpic:@ee402000,virq:29,src:0x1d,type:0x4)

    if (src >= mpic->irq_count)
        return -EINVAL;

    if (flow_type == IRQ_TYPE_NONE)
        if (mpic->senses && src < mpic->senses_count)
            flow_type = mpic->senses[src];
    if (flow_type == IRQ_TYPE_NONE)
        flow_type = IRQ_TYPE_LEVEL_LOW;

    desc->status &= ~(IRQ_TYPE_SENSE_MASK | IRQ_LEVEL);
    desc->status |= flow_type & IRQ_TYPE_SENSE_MASK;
    if (flow_type & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
        desc->status |= IRQ_LEVEL;

    if (mpic_is_ht_interrupt(mpic, src))
        vecpri = MPIC_VECPRI_POLARITY_POSITIVE |
            MPIC_VECPRI_SENSE_EDGE;
    else
        vecpri = mpic_type_to_vecpri(mpic, flow_type);//把flow_type转换为具体的触发方式

    vold = mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI));//读取向量/优先级寄存器
    vnew = vold & ~(MPIC_INFO(VECPRI_POLARITY_MASK) |
            MPIC_INFO(VECPRI_SENSE_MASK));
    vnew |= vecpri;
    if (vold != vnew)
        mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI), vnew);

    return 0;
}
阅读(7642) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~