Changeset c01bb5f9 in mainline for kernel


Ignore:
Timestamp:
2012-02-16T21:21:39Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
39aa8ce, 856a36b, f943dd3
Parents:
edd7c63c (diff), 21063c2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~jakub/helenos/mm.

Location:
kernel
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

    redd7c63c rc01bb5f9  
    332332        sysinfo_set_item_val("kbd", NULL, true);
    333333        sysinfo_set_item_val("kbd.inr", NULL, ICP_KBD_IRQ);
    334         sysinfo_set_item_val("kbd.address.status", NULL,
    335             (uintptr_t) icp_hw_map.kbd_stat);
    336         sysinfo_set_item_val("kbd.address.data", NULL,
    337             (uintptr_t) icp_hw_map.kbd_data);
     334        sysinfo_set_item_val("kbd.address.physical", NULL,
     335            ICP_KBD);
    338336
    339337}

  • kernel/arch/arm32/src/mach/testarm/testarm.c

    redd7c63c rc01bb5f9  
    128128        sysinfo_set_item_val("kbd", NULL, true);
    129129        sysinfo_set_item_val("kbd.inr", NULL, GXEMUL_KBD_IRQ);
    130         sysinfo_set_item_val("kbd.address.virtual", NULL, (sysarg_t) gxemul_kbd);
     130        sysinfo_set_item_val("kbd.address.physical", NULL,
     131            GXEMUL_KBD_ADDRESS);
    131132#endif
    132133}

  • kernel/arch/ia64/src/ia64.c

    redd7c63c rc01bb5f9  
    188188        sysinfo_set_item_val("kbd.address.physical", NULL,
    189189            (uintptr_t) NS16550_BASE);
    190         sysinfo_set_item_val("kbd.address.kernel", NULL,
    191             (uintptr_t) NS16550_BASE);
    192190#endif
    193191       

  • kernel/arch/mips32/src/mips32.c

    redd7c63c rc01bb5f9  
    196196        sysinfo_set_item_val("kbd", NULL, true);
    197197        sysinfo_set_item_val("kbd.inr", NULL, MSIM_KBD_IRQ);
    198         sysinfo_set_item_val("kbd.address.virtual", NULL, MSIM_KBD_ADDRESS);
     198        sysinfo_set_item_val("kbd.address.physical", NULL,
     199            PA2KA(MSIM_KBD_ADDRESS));
    199200#endif
    200201}

  • kernel/arch/ppc32/src/ppc32.c

    redd7c63c rc01bb5f9  
    232232                sysinfo_set_item_val("cuda.inr", NULL, IRQ_CUDA);
    233233                sysinfo_set_item_val("cuda.address.physical", NULL, pa);
    234                 sysinfo_set_item_val("cuda.address.kernel", NULL,
    235                     (uintptr_t) cuda);
    236234#endif
    237235        }

  • kernel/arch/sparc64/src/drivers/kbd.c

    redd7c63c rc01bb5f9  
    133133        sysinfo_set_item_val("kbd", NULL, true);
    134134        sysinfo_set_item_val("kbd.inr", NULL, inr);
    135         sysinfo_set_item_val("kbd.address.kernel", NULL,
    136             (uintptr_t) ns16550);
    137135        sysinfo_set_item_val("kbd.address.physical", NULL, pa);
    138136        sysinfo_set_item_val("kbd.type.ns16550", NULL, true);

  • kernel/generic/include/ddi/irq.h

    redd7c63c rc01bb5f9  
    134134        /** Notification configuration structure. */
    135135        ipc_notif_cfg_t notif_cfg;
    136        
    137         as_t *driver_as;
    138136} irq_t;
    139137

  • kernel/generic/include/ipc/irq.h

    redd7c63c rc01bb5f9  
    3636#define KERN_IPC_IRQ_H_
    3737
    38 /** Maximum length of IPC IRQ program */
     38/** Maximum number of IPC IRQ programmed I/O ranges. */
     39#define IRQ_MAX_RANGE_COUNT     8
     40
     41/** Maximum length of IPC IRQ program. */
    3942#define IRQ_MAX_PROG_SIZE  20
    4043

  • kernel/generic/src/ipc/irq.c

    redd7c63c rc01bb5f9  
    7474#include <arch.h>
    7575#include <mm/slab.h>
     76#include <mm/page.h>
     77#include <mm/km.h>
    7678#include <errno.h>
    7779#include <ddi/irq.h>
    … …  
    8183#include <console/console.h>
    8284#include <print.h>
     85#include <macros.h>
     86
     87static void ranges_unmap(irq_pio_range_t *ranges, size_t rangecount)
     88{
     89        size_t i;
     90
     91        for (i = 0; i < rangecount; i++) {
     92#ifdef IO_SPACE_BOUNDARY
     93                if ((void *) ranges[i].base >= IO_SPACE_BOUNDARY)
     94#endif
     95                        km_unmap(ranges[i].base, ranges[i].size);
     96        }
     97}
     98
     99static int ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
     100    irq_cmd_t *cmds, size_t cmdcount)
     101{
     102        uintptr_t *pbase;
     103        size_t i, j;
     104
     105        /* Copy the physical base addresses aside. */
     106        pbase = malloc(rangecount * sizeof(uintptr_t), 0);
     107        for (i = 0; i < rangecount; i++)
     108                pbase[i] = ranges[i].base;
     109
     110        /* Map the PIO ranges into the kernel virtual address space. */
     111        for (i = 0; i < rangecount; i++) {
     112#ifdef IO_SPACE_BOUNDARY
     113                if ((void *) ranges[i].base < IO_SPACE_BOUNDARY)
     114                        continue;
     115#endif
     116                ranges[i].base = km_map(pbase[i], ranges[i].size,
     117                    PAGE_READ | PAGE_WRITE | PAGE_KERNEL | PAGE_NOT_CACHEABLE);
     118                if (!ranges[i].base) {
     119                        ranges_unmap(ranges, i);
     120                        free(pbase);
     121                        return ENOMEM;
     122                }
     123        }
     124
     125        /* Rewrite the pseudocode addresses from physical to kernel virtual. */
     126        for (i = 0; i < cmdcount; i++) {
     127                uintptr_t addr;
     128                size_t size;
     129
     130                /* Process only commands that use an address. */
     131                switch (cmds[i].cmd) {
     132                case CMD_PIO_READ_8:
     133                case CMD_PIO_WRITE_8:
     134                case CMD_PIO_WRITE_A_8:
     135                        size = 1;
     136                        break;
     137                case CMD_PIO_READ_16:
     138                case CMD_PIO_WRITE_16:
     139                case CMD_PIO_WRITE_A_16:
     140                        size = 2;
     141                        break;
     142                case CMD_PIO_READ_32:
     143                case CMD_PIO_WRITE_32:
     144                case CMD_PIO_WRITE_A_32:
     145                        size = 4;
     146                        break;
     147                default:
     148                        /* Move onto the next command. */
     149                        continue;
     150                }
     151
     152                addr = (uintptr_t) cmds[i].addr;
     153               
     154                for (j = 0; j < rangecount; j++) {
     155
     156                        /* Find the matching range. */
     157                        if (!iswithin(pbase[j], ranges[j].size, addr, size))
     158                                continue;
     159
     160                        /* Switch the command to a kernel virtual address. */
     161                        addr -= pbase[j];
     162                        addr += ranges[j].base;
     163
     164                        cmds[i].addr = (void *) addr;
     165                        break;
     166                }
     167
     168                if (j == rangecount) {
     169                        /*
     170                         * The address used in this command is outside of all
     171                         * defined ranges.
     172                         */
     173                        ranges_unmap(ranges, rangecount);
     174                        free(pbase);
     175                        return EINVAL;
     176                }
     177        }
     178
     179        free(pbase);
     180        return EOK;
     181}
    83182
    84183/** Free the top-half pseudocode.
    … …  
    90189{
    91190        if (code) {
     191                ranges_unmap(code->ranges, code->rangecount);
     192                free(code->ranges);
    92193                free(code->cmds);
    93194                free(code);
    … …  
    104205static irq_code_t *code_from_uspace(irq_code_t *ucode)
    105206{
     207        irq_pio_range_t *ranges = NULL;
     208        irq_cmd_t *cmds = NULL;
     209
    106210        irq_code_t *code = malloc(sizeof(*code), 0);
    107211        int rc = copy_from_uspace(code, ucode, sizeof(*code));
    108         if (rc != 0) {
    109                 free(code);
    110                 return NULL;
    111         }
    112        
    113         if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
    114                 free(code);
    115                 return NULL;
    116         }
    117        
    118         irq_cmd_t *ucmds = code->cmds;
    119         code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
    120         rc = copy_from_uspace(code->cmds, ucmds,
     212        if (rc != EOK)
     213                goto error;
     214       
     215        if ((code->rangecount > IRQ_MAX_RANGE_COUNT) ||
     216            (code->cmdcount > IRQ_MAX_PROG_SIZE))
     217                goto error;
     218       
     219        ranges = malloc(sizeof(code->ranges[0]) * code->rangecount, 0);
     220        rc = copy_from_uspace(ranges, code->ranges,
     221            sizeof(code->ranges[0]) * code->rangecount);
     222        if (rc != EOK)
     223                goto error;
     224
     225        cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
     226        rc = copy_from_uspace(cmds, code->cmds,
    121227            sizeof(code->cmds[0]) * code->cmdcount);
    122         if (rc != 0) {
    123                 free(code->cmds);
    124                 free(code);
    125                 return NULL;
    126         }
    127        
     228        if (rc != EOK)
     229                goto error;
     230
     231        rc = ranges_map_and_apply(ranges, code->rangecount, cmds,
     232            code->cmdcount);
     233        if (rc != EOK)
     234                goto error;
     235
     236        code->ranges = ranges;
     237        code->cmds = cmds;
     238
    128239        return code;
     240
     241error:
     242        if (cmds)
     243                free(cmds);
     244        if (ranges)
     245                free(ranges);
     246        free(code);
     247        return NULL;
    129248}
    130249
    … …  
    174293        irq->notif_cfg.code = code;
    175294        irq->notif_cfg.counter = 0;
    176         irq->driver_as = AS;
    177295       
    178296        /*
    … …  
    365483                return IRQ_DECLINE;
    366484       
    367         as_t *current_as = AS;
    368         if (current_as != irq->driver_as)
    369                 as_switch(AS, irq->driver_as);
    370        
    371485        for (size_t i = 0; i < code->cmdcount; i++) {
    372486                uint32_t dstval;
    373                 void *va;
    374                 uint8_t val8;
    375                 uint16_t val16;
    376                 uint32_t val32;
    377487               
    378488                uintptr_t srcarg = code->cmds[i].srcarg;
    … …  
    431541                        }
    432542                        break;
    433                 case CMD_MEM_READ_8:
    434                         va = code->cmds[i].addr;
    435                         memcpy_from_uspace(&val8, va, sizeof(val8));
    436                         if (dstarg)
    437                                 scratch[dstarg] = val8;
    438                         break;
    439                 case CMD_MEM_READ_16:
    440                         va = code->cmds[i].addr;
    441                         memcpy_from_uspace(&val16, va, sizeof(val16));
    442                         if (dstarg)
    443                                 scratch[dstarg] = val16;
    444                         break;
    445                 case CMD_MEM_READ_32:
    446                         va = code->cmds[i].addr;
    447                         memcpy_from_uspace(&val32, va, sizeof(val32));
    448                         if (dstarg)
    449                                 scratch[dstarg] = val32;
    450                         break;
    451                 case CMD_MEM_WRITE_8:
    452                         val8 = code->cmds[i].value;
    453                         va = code->cmds[i].addr;
    454                         memcpy_to_uspace(va, &val8, sizeof(val8));
    455                         break;
    456                 case CMD_MEM_WRITE_16:
    457                         val16 = code->cmds[i].value;
    458                         va = code->cmds[i].addr;
    459                         memcpy_to_uspace(va, &val16, sizeof(val16));
    460                         break;
    461                 case CMD_MEM_WRITE_32:
    462                         val32 = code->cmds[i].value;
    463                         va = code->cmds[i].addr;
    464                         memcpy_to_uspace(va, &val32, sizeof(val32));
    465                         break;
    466                 case CMD_MEM_WRITE_A_8:
    467                         if (srcarg) {
    468                                 val8 = scratch[srcarg];
    469                                 va = code->cmds[i].addr;
    470                                 memcpy_to_uspace(va, &val8, sizeof(val8));
    471                         }
    472                         break;
    473                 case CMD_MEM_WRITE_A_16:
    474                         if (srcarg) {
    475                                 val16 = scratch[srcarg];
    476                                 va = code->cmds[i].addr;
    477                                 memcpy_to_uspace(va, &val16, sizeof(val16));
    478                         }
    479                         break;
    480                 case CMD_MEM_WRITE_A_32:
    481                         if (srcarg) {
    482                                 val32 = scratch[srcarg];
    483                                 va = code->cmds[i].addr;
    484                                 memcpy_to_uspace(va, &val32, sizeof(val32));
    485                         }
    486                         break;
    487543                case CMD_BTEST:
    488544                        if ((srcarg) && (dstarg)) {
    … …  
    498554                        break;
    499555                case CMD_ACCEPT:
    500                         if (AS != current_as)
    501                                 as_switch(AS, current_as);
    502556                        return IRQ_ACCEPT;
    503557                case CMD_DECLINE:
    504558                default:
    505                         if (AS != current_as)
    506                                 as_switch(AS, current_as);
    507559                        return IRQ_DECLINE;
    508560                }
    509561        }
    510        
    511         if (AS != current_as)
    512                 as_switch(AS, current_as);
    513562       
    514563        return IRQ_DECLINE;

  • kernel/generic/src/syscall/copy.c

    redd7c63c rc01bb5f9  
    5656 * @param size Size of the data to be copied.
    5757 *
    58  * @return 0 on success or error code from @ref errno.h.
     58 * @return EOK on success or error code from @ref errno.h.
    5959 */
    6060int copy_from_uspace(void *dst, const void *uspace_src, size_t size)
    … …  
    9494
    9595        interrupts_restore(ipl);
    96         return !rc ? EPERM : 0;
     96        return !rc ? EPERM : EOK;
    9797}
    9898
Note: See TracChangeset for help on using the changeset viewer.