Ignore:
File:
1 edited

Legend:

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

    r5a6cc679 ra35b458  
    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.