Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/ipc/irq.c

    ra35b458 r5a6cc679  
    8585        for (size_t i = 0; i < rangecount; i++)
    8686                pbase[i] = ranges[i].base;
    87 
     87       
    8888        /* Map the PIO ranges into the kernel virtual address space. */
    8989        for (size_t i = 0; i < rangecount; i++) {
     
    100100                }
    101101        }
    102 
     102       
    103103        /* Rewrite the IRQ code addresses from physical to kernel virtual. */
    104104        for (size_t i = 0; i < cmdcount; i++) {
    105105                uintptr_t addr;
    106106                size_t size;
    107 
     107               
    108108                /* Process only commands that use an address. */
    109109                switch (cmds[i].cmd) {
     
    127127                        continue;
    128128                }
    129 
     129               
    130130                addr = (uintptr_t) cmds[i].addr;
    131 
     131               
    132132                size_t j;
    133133                for (j = 0; j < rangecount; j++) {
     
    135135                        if (!iswithin(pbase[j], ranges[j].size, addr, size))
    136136                                continue;
    137 
     137                       
    138138                        /* Switch the command to a kernel virtual address. */
    139139                        addr -= pbase[j];
    140140                        addr += ranges[j].base;
    141 
     141                       
    142142                        cmds[i].addr = (void *) addr;
    143143                        break;
    144144                }
    145 
     145               
    146146                if (j == rangecount) {
    147147                        /*
     
    154154                }
    155155        }
    156 
     156       
    157157        free(pbase);
    158158        return EOK;
     
    172172                if (cmds[i].cmd >= CMD_LAST)
    173173                        return EINVAL;
    174 
     174               
    175175                if (cmds[i].srcarg >= IPC_CALL_LEN)
    176176                        return EINVAL;
    177 
     177               
    178178                if (cmds[i].dstarg >= IPC_CALL_LEN)
    179179                        return EINVAL;
    180 
     180               
    181181                switch (cmds[i].cmd) {
    182182                case CMD_PREDICATE:
     
    188188                        if (i + cmds[i].value > cmdcount)
    189189                                return EINVAL;
    190 
     190                       
    191191                        break;
    192192                default:
     
    194194                }
    195195        }
    196 
     196       
    197197        return EOK;
    198198}
     
    224224        irq_pio_range_t *ranges = NULL;
    225225        irq_cmd_t *cmds = NULL;
    226 
     226       
    227227        irq_code_t *code = malloc(sizeof(*code), 0);
    228228        errno_t rc = copy_from_uspace(code, ucode, sizeof(*code));
    229229        if (rc != EOK)
    230230                goto error;
    231 
     231       
    232232        if ((code->rangecount > IRQ_MAX_RANGE_COUNT) ||
    233233            (code->cmdcount > IRQ_MAX_PROG_SIZE))
    234234                goto error;
    235 
     235       
    236236        ranges = malloc(sizeof(code->ranges[0]) * code->rangecount, 0);
    237237        rc = copy_from_uspace(ranges, code->ranges,
     
    239239        if (rc != EOK)
    240240                goto error;
    241 
     241       
    242242        cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
    243243        rc = copy_from_uspace(cmds, code->cmds,
     
    245245        if (rc != EOK)
    246246                goto error;
    247 
     247       
    248248        rc = code_check(cmds, code->cmdcount);
    249249        if (rc != EOK)
    250250                goto error;
    251 
     251       
    252252        rc = ranges_map_and_apply(ranges, code->rangecount, cmds,
    253253            code->cmdcount);
    254254        if (rc != EOK)
    255255                goto error;
    256 
     256       
    257257        code->ranges = ranges;
    258258        code->cmds = cmds;
    259 
     259       
    260260        return code;
    261 
     261       
    262262error:
    263263        if (cmds)
    264264                free(cmds);
    265 
     265       
    266266        if (ranges)
    267267                free(ranges);
    268 
     268       
    269269        free(code);
    270270        return NULL;
     
    275275        irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
    276276        irq_spinlock_lock(&irq->lock, false);
    277 
     277       
    278278        if (irq->notif_cfg.hashed_in) {
    279279                /* Remove the IRQ from the uspace IRQ hash table. */
     
    318318        if ((inr < 0) || (inr > last_inr))
    319319                return ELIMIT;
    320 
     320       
    321321        irq_code_t *code;
    322322        if (ucode) {
     
    326326        } else
    327327                code = NULL;
    328 
     328       
    329329        /*
    330330         * Allocate and populate the IRQ kernel object.
     
    334334        if (rc != EOK)
    335335                return rc;
    336 
     336       
    337337        rc = copy_to_uspace(uspace_handle, &handle, sizeof(cap_handle_t));
    338338        if (rc != EOK) {
     
    353353                return ENOMEM;
    354354        }
    355 
     355       
    356356        irq_initialize(irq);
    357357        irq->inr = inr;
     
    363363        irq->notif_cfg.code = code;
    364364        irq->notif_cfg.counter = 0;
    365 
     365       
    366366        /*
    367367         * Insert the IRQ structure into the uspace IRQ hash table.
     
    369369        irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
    370370        irq_spinlock_lock(&irq->lock, false);
    371 
     371       
    372372        irq->notif_cfg.hashed_in = true;
    373373        hash_table_insert(&irq_uspace_hash_table, &irq->link);
    374 
     374       
    375375        irq_spinlock_unlock(&irq->lock, false);
    376376        irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
     
    378378        kobject_initialize(kobject, KOBJECT_TYPE_IRQ, irq, &irq_kobject_ops);
    379379        cap_publish(TASK, handle, kobject);
    380 
     380       
    381381        return EOK;
    382382}
     
    395395        if (!kobj)
    396396                return ENOENT;
    397 
     397       
    398398        assert(kobj->irq->notif_cfg.answerbox == box);
    399399
     
    402402        kobject_put(kobj);
    403403        cap_free(TASK, handle);
    404 
     404       
    405405        return EOK;
    406406}
     
    419419        list_append(&call->ab_link, &irq->notif_cfg.answerbox->irq_notifs);
    420420        irq_spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock, false);
    421 
     421       
    422422        waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
    423423}
     
    435435        irq_code_t *code = irq->notif_cfg.code;
    436436        uint32_t *scratch = irq->notif_cfg.scratch;
    437 
     437       
    438438        if (!irq->notif_cfg.notify)
    439439                return IRQ_DECLINE;
    440 
     440       
    441441        if (!code)
    442442                return IRQ_DECLINE;
    443 
     443       
    444444        for (size_t i = 0; i < code->cmdcount; i++) {
    445445                uintptr_t srcarg = code->cmds[i].srcarg;
    446446                uintptr_t dstarg = code->cmds[i].dstarg;
    447 
     447               
    448448                switch (code->cmds[i].cmd) {
    449449                case CMD_PIO_READ_8:
     
    493493                        if (scratch[srcarg] == 0)
    494494                                i += code->cmds[i].value;
    495 
     495                       
    496496                        break;
    497497                case CMD_ACCEPT:
     
    502502                }
    503503        }
    504 
     504       
    505505        return IRQ_DECLINE;
    506506}
     
    516516{
    517517        assert(irq);
    518 
     518       
    519519        assert(interrupts_disabled());
    520520        assert(irq_spinlock_locked(&irq->lock));
    521 
     521       
    522522        if (irq->notif_cfg.answerbox) {
    523523                call_t *call = ipc_call_alloc(FRAME_ATOMIC);
    524524                if (!call)
    525525                        return;
    526 
     526               
    527527                call->flags |= IPC_CALL_NOTIF;
    528528                /* Put a counter to the message */
    529529                call->priv = ++irq->notif_cfg.counter;
    530 
     530               
    531531                /* Set up args */
    532532                IPC_SET_IMETHOD(call->data, irq->notif_cfg.imethod);
     
    536536                IPC_SET_ARG4(call->data, irq->notif_cfg.scratch[4]);
    537537                IPC_SET_ARG5(call->data, irq->notif_cfg.scratch[5]);
    538 
     538               
    539539                send_call(irq, call);
    540540        }
     
    555555{
    556556        irq_spinlock_lock(&irq->lock, true);
    557 
     557       
    558558        if (irq->notif_cfg.answerbox) {
    559559                call_t *call = ipc_call_alloc(FRAME_ATOMIC);
     
    562562                        return;
    563563                }
    564 
     564               
    565565                call->flags |= IPC_CALL_NOTIF;
    566566                /* Put a counter to the message */
    567567                call->priv = ++irq->notif_cfg.counter;
    568 
     568               
    569569                IPC_SET_IMETHOD(call->data, irq->notif_cfg.imethod);
    570570                IPC_SET_ARG1(call->data, a1);
     
    573573                IPC_SET_ARG4(call->data, a4);
    574574                IPC_SET_ARG5(call->data, a5);
    575 
     575               
    576576                send_call(irq, call);
    577577        }
    578 
     578       
    579579        irq_spinlock_unlock(&irq->lock, true);
    580580}
Note: See TracChangeset for help on using the changeset viewer.