Changeset 666773c in mainline


Ignore:
Timestamp:
2008-12-31T15:33:29Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9805cde
Parents:
d8c0dc5
Message:

Humanitarian facelift for ia64.

Location:
kernel/arch/ia64/src
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/ia64/src/cpu/cpu.c

    rd8c0dc5 r666773c  
    7171       
    7272        printf("cpu%d: %s (%s), archrev=%d, model=%d, revision=%d\n", CPU->id,
    73             family_str, vendor, CPU->arch.cpuid3.archrev, CPU->arch.cpuid3.model,
    74             CPU->arch.cpuid3.revision);
     73            family_str, vendor, CPU->arch.cpuid3.archrev,
     74            CPU->arch.cpuid3.model, CPU->arch.cpuid3.revision);
    7575}
    7676
  • kernel/arch/ia64/src/ddi/ddi.c

    rd8c0dc5 r666773c  
    11/*
    2  * Copyright (c) 2006 Jakub Jermar, Jakub vana
     2 * Copyright (c) 2006 Jakub Jermar
     3 * Copyright (c) 2008 Jakub vana
    34 * All rights reserved.
    45 *
     
    3940#include <errno.h>
    4041
    41 #define IO_MEMMAP_PAGES 16384
    42 #define PORTS_PER_PAGE 4
     42#define IO_MEMMAP_PAGES 16384
     43#define PORTS_PER_PAGE  4
    4344
    4445/** Enable I/O space range for task.
     
    4647 * Interrupts are disabled and task is locked.
    4748 *
    48  * @param task Task.
    49  * @param ioaddr Startign I/O space address.
    50  * @param size Size of the enabled I/O range.
     49 * @param task          Task.
     50 * @param ioaddr        Starting I/O space address.
     51 * @param size          Size of the enabled I/O range.
    5152 *
    5253 * @return 0 on success or an error code from errno.h.
     
    5455int ddi_iospace_enable_arch(task_t *task, uintptr_t ioaddr, size_t size)
    5556{
     57        if (!task->arch.iomap) {
     58                uint8_t *map;
    5659
    57         if(!task->arch.iomap)
    58         {
    59                 uint8_t *map;
    60                 task->arch.iomap=malloc(sizeof(bitmap_t),0);
    61                 map=malloc(BITS2BYTES(IO_MEMMAP_PAGES),0);
     60                task->arch.iomap = malloc(sizeof(bitmap_t), 0);
     61                map = malloc(BITS2BYTES(IO_MEMMAP_PAGES), 0);
    6262                if(!map)
    6363                        return ENOMEM;
    64                 bitmap_initialize(task->arch.iomap,map,IO_MEMMAP_PAGES);       
    65                 bitmap_clear_range(task->arch.iomap,0,IO_MEMMAP_PAGES);
     64                bitmap_initialize(task->arch.iomap, map, IO_MEMMAP_PAGES);
     65                bitmap_clear_range(task->arch.iomap, 0, IO_MEMMAP_PAGES);
    6666        }
    6767       
    6868        uintptr_t iopage = ioaddr / PORTS_PER_PAGE;
    69         size = ALIGN_UP (size+ioaddr-4*iopage,PORTS_PER_PAGE);
    70         bitmap_set_range(task->arch.iomap,iopage,size/4);
    71 
     69        size = ALIGN_UP(size + ioaddr - 4 * iopage, PORTS_PER_PAGE);
     70        bitmap_set_range(task->arch.iomap, iopage, size / 4);
    7271
    7372        return 0;
  • kernel/arch/ia64/src/drivers/ega.c

    rd8c0dc5 r666773c  
    8383        stdout = &ega_console;
    8484
    85 
    8685        ega_parea.pbase = VIDEORAM & 0xffffffff;
    8786        ega_parea.vbase = (uintptr_t) videoram;
     
    9089        ddi_parea_register(&ega_parea);
    9190
    92        
    9391        sysinfo_set_item_val("fb", NULL, true);
    9492        sysinfo_set_item_val("fb.kind", NULL, 2);
     
    9694        sysinfo_set_item_val("fb.height", NULL, ROWS);
    9795        sysinfo_set_item_val("fb.blinking", NULL, true);
    98         sysinfo_set_item_val("fb.address.physical", NULL, VIDEORAM & 0xffffffff);
     96        sysinfo_set_item_val("fb.address.physical", NULL,
     97            VIDEORAM & 0xffffffff);
    9998       
    10099#ifndef CONFIG_FB
     
    117116                return;
    118117
    119         memmove((void *) videoram, (void *) (videoram + ROW * 2), (SCREEN - ROW) * 2);
     118        memmove((void *) videoram, (void *) (videoram + ROW * 2),
     119            (SCREEN - ROW) * 2);
    120120        _memsetw(videoram + (SCREEN - ROW) * 2, ROW, 0x0720);
    121121        ega_cursor = ega_cursor - ROW;
  • kernel/arch/ia64/src/drivers/it.c

    rd8c0dc5 r666773c  
    4545#include <arch.h>
    4646
    47 #define IT_SERVICE_CLOCKS 64
     47#define IT_SERVICE_CLOCKS       64
    4848
    49 #define FREQ_NUMERATOR_SHIFT 32
    50 #define FREQ_NUMERATOR_MASK 0xffffffff00000000LL
     49#define FREQ_NUMERATOR_SHIFT    32
     50#define FREQ_NUMERATOR_MASK     0xffffffff00000000ULL
    5151
    52 #define FREQ_DENOMINATOR_SHIFT 0
    53 #define FREQ_DENOMINATOR_MASK 0xffffffffLL
    54 
     52#define FREQ_DENOMINATOR_SHIFT  0
     53#define FREQ_DENOMINATOR_MASK   0xffffffffULL
    5554
    5655uint64_t it_delta;
    57 
    5856
    5957static irq_t it_irq;
     
    6765        cr_itv_t itv;
    6866       
    69         if(config.cpu_active==1)
    70         {
     67        if (config.cpu_active == 1) {
    7168                irq_initialize(&it_irq);
    7269                it_irq.inr = INTERRUPT_TIMER;
     
    7774               
    7875                uint64_t base_freq;
    79                 base_freq  = ((bootinfo->freq_scale) & FREQ_NUMERATOR_MASK) >> FREQ_NUMERATOR_SHIFT;
     76                base_freq  = ((bootinfo->freq_scale) & FREQ_NUMERATOR_MASK) >>
     77                    FREQ_NUMERATOR_SHIFT;
    8078                base_freq *= bootinfo->sys_freq;
    81                 base_freq /= ((bootinfo->freq_scale) & FREQ_DENOMINATOR_MASK) >> FREQ_DENOMINATOR_SHIFT;
     79                base_freq /= ((bootinfo->freq_scale) & FREQ_DENOMINATOR_MASK) >>
     80                    FREQ_DENOMINATOR_SHIFT;
    8281               
    83                 it_delta = base_freq /HZ;
    84                
     82                it_delta = base_freq / HZ;
    8583        }
    8684       
  • kernel/arch/ia64/src/fpu_context.c

    rd8c0dc5 r666773c  
    150150
    151151                :
    152                 : "r" (&((fctx->fr)[0])), "r" (&((fctx->fr)[1])), "r" (&((fctx->fr)[2])), "r" (&((fctx->fr)[3])),
    153                   "r" (&((fctx->fr)[4])), "r" (&((fctx->fr)[5])), "r" (&((fctx->fr)[6])), "r" (&((fctx->fr)[7]))
     152                : "r" (&((fctx->fr)[0])), "r" (&((fctx->fr)[1])),
     153                  "r" (&((fctx->fr)[2])), "r" (&((fctx->fr)[3])),
     154                  "r" (&((fctx->fr)[4])), "r" (&((fctx->fr)[5])),
     155                  "r" (&((fctx->fr)[6])), "r" (&((fctx->fr)[7]))
    154156        );
    155157       
     
    268270
    269271                :
    270                 : "r" (&((fctx->fr)[0])), "r" (&((fctx->fr)[1])), "r" (&((fctx->fr)[2])), "r" (&((fctx->fr)[3])),
    271                   "r" (&((fctx->fr)[4])), "r" (&((fctx->fr)[5])), "r" (&((fctx->fr)[6])), "r" (&((fctx->fr)[7]))
     272                : "r" (&((fctx->fr)[0])), "r" (&((fctx->fr)[1])),
     273                  "r" (&((fctx->fr)[2])), "r" (&((fctx->fr)[3])),
     274                  "r" (&((fctx->fr)[4])), "r" (&((fctx->fr)[5])),
     275                  "r" (&((fctx->fr)[6])), "r" (&((fctx->fr)[7]))
    272276        );
    273277}
     
    275279void fpu_enable(void)
    276280{
    277         uint64_t a = 0 ;
     281        uint64_t a = 0;
    278282
    279283        asm volatile (
  • kernel/arch/ia64/src/ia64.c

    rd8c0dc5 r666773c  
    6363#include <sysinfo/sysinfo.h>
    6464
    65 /*NS16550 as a COM 1*/
    66 #define NS16550_IRQ (4+LEGACY_INTERRUPT_BASE)
    67 #define NS16550_PORT 0x3f8
     65/* NS16550 as a COM 1 */
     66#define NS16550_IRQ     (4 + LEGACY_INTERRUPT_BASE)
     67#define NS16550_PORT    0x3f8
    6868
    6969bootinfo_t *bootinfo;
    7070
    71 static uint64_t iosapic_base=0xfec00000;
     71static uint64_t iosapic_base = 0xfec00000;
    7272
    7373void arch_pre_main(void)
     
    8080       
    8181        for (i = 0; i < init.cnt; i++) {
    82                 init.tasks[i].addr = ((unsigned long) bootinfo->taskmap.tasks[i].addr) | VRN_MASK;
     82                init.tasks[i].addr =
     83                    ((unsigned long) bootinfo->taskmap.tasks[i].addr) |
     84                    VRN_MASK;
    8385                init.tasks[i].size = bootinfo->taskmap.tasks[i].size;
    8486        }
     
    8789void arch_pre_mm_init(void)
    8890{
    89         /* Set Interruption Vector Address (i.e. location of interruption vector table). */
     91        /*
     92         * Set Interruption Vector Address (i.e. location of interruption vector
     93         * table).
     94         */
    9095        iva_write((uintptr_t) &ivt);
    9196        srlz_d();
     
    96101{
    97102
    98         uint64_t IOSAPIC = PA2KA((unative_t)(iosapic_base))|FW_OFFSET;
     103        uint64_t IOSAPIC = PA2KA((unative_t)(iosapic_base)) | FW_OFFSET;
    99104        int i;
    100105       
    101106        int myid,myeid;
    102107       
    103         myid=ia64_get_cpu_id();
    104         myeid=ia64_get_cpu_eid();
    105 
    106         for(i=0;i<16;i++)
    107         {
    108        
    109                 if(i==2) continue;       //Disable Cascade interrupt
    110                 ((uint32_t*)(IOSAPIC+0x00))[0]=0x10+2*i;
    111                 srlz_d();
    112                 ((uint32_t*)(IOSAPIC+0x10))[0]=LEGACY_INTERRUPT_BASE+i;
    113                 srlz_d();
    114                 ((uint32_t*)(IOSAPIC+0x00))[0]=0x10+2*i+1;
    115                 srlz_d();
    116                 ((uint32_t*)(IOSAPIC+0x10))[0]=myid<<(56-32) | myeid<<(48-32);
     108        myid = ia64_get_cpu_id();
     109        myeid = ia64_get_cpu_eid();
     110
     111        for (i = 0; i < 16; i++) {
     112                if (i == 2)
     113                        continue;        /* Disable Cascade interrupt */
     114                ((uint32_t *)(IOSAPIC + 0x00))[0] = 0x10 + 2 * i;
     115                srlz_d();
     116                ((uint32_t *)(IOSAPIC + 0x10))[0] = LEGACY_INTERRUPT_BASE + i;
     117                srlz_d();
     118                ((uint32_t *)(IOSAPIC + 0x00))[0] = 0x10 + 2 * i + 1;
     119                srlz_d();
     120                ((uint32_t *)(IOSAPIC + 0x10))[0] = myid << (56 - 32) |
     121                    myeid << (48 - 32);
    117122                srlz_d();
    118123        }
     
    123128void arch_post_mm_init(void)
    124129{
    125         if(config.cpu_active==1)
    126         {
     130        if (config.cpu_active == 1) {
    127131                iosapic_init();
    128        
    129132                irq_init(INR_COUNT, INR_COUNT);
    130133#ifdef SKI
     
    167170#endif
    168171
    169 
    170 void end_of_irq_void(void *cir_arg __attribute__((unused)),inr_t inr __attribute__((unused)));
    171 void end_of_irq_void(void *cir_arg __attribute__((unused)),inr_t inr __attribute__((unused)))
    172 {
    173         return;
    174 }
    175 
    176 
    177172void arch_post_smp_init(void)
    178173{
    179 
    180         {
    181                 /*
    182                  * Create thread that polls keyboard.
    183                  */
    184 #ifdef SKI
    185                 thread_t *t;
    186                 t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    187                 if (!t)
    188                         panic("cannot create kkbdpoll\n");
    189                 thread_ready(t);
     174        thread_t *t;
     175
     176        /*
     177         * Create thread that polls keyboard.
     178         */
     179#ifdef SKI
     180        t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
     181        if (!t)
     182                panic("cannot create kkbdpoll\n");
     183        thread_ready(t);
    190184#endif         
    191185
    192186#ifdef I460GX
    193                 devno_t kbd = device_assign_devno();
    194                 /* keyboard controller */
    195 
    196 #ifdef CONFIG_NS16550
    197                 ns16550_init(kbd, NS16550_PORT, NS16550_IRQ,end_of_irq_void,NULL); // as a COM 1
    198 #else
    199                 devno_t mouse = device_assign_devno();
    200                 i8042_init(kbd, IRQ_KBD, mouse, IRQ_MOUSE);
    201 #endif
    202                 thread_t *t;
    203                 t = thread_create(i8042_kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
    204                 if (!t)
    205                         panic("cannot create kkbdpoll\n");
    206                 thread_ready(t);
    207 
    208 #endif
    209 
    210         }
    211        
     187        devno_t kbd = device_assign_devno();
     188
     189#ifdef CONFIG_NS16550
     190        ns16550_init(kbd, NS16550_PORT, NS16550_IRQ, NULL, NULL);
     191#else
     192        devno_t mouse = device_assign_devno();
     193        i8042_init(kbd, IRQ_KBD, mouse, IRQ_MOUSE);
     194#endif
     195        t = thread_create(i8042_kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
     196        if (!t)
     197                panic("cannot create kkbdpoll\n");
     198        thread_ready(t);
     199#endif
     200
    212201        sysinfo_set_item_val("ia64_iospace", NULL, true);
    213202        sysinfo_set_item_val("ia64_iospace.address", NULL, true);
    214203        sysinfo_set_item_val("ia64_iospace.address.virtual", NULL, IO_OFFSET);
    215 
    216 
    217 
    218 
    219 
    220204}
    221205
     
    229213        psr.value = psr_read();
    230214        psr.cpl = PL_USER;
    231         psr.i = true;                           /* start with interrupts enabled */
     215        psr.i = true;                   /* start with interrupts enabled */
    232216        psr.ic = true;
    233         psr.ri = 0;                             /* start with instruction #0 */
    234         psr.bn = 1;                             /* start in bank 0 */
     217        psr.ri = 0;                     /* start with instruction #0 */
     218        psr.bn = 1;                     /* start in bank 0 */
    235219
    236220        asm volatile ("mov %0 = ar.rsc\n" : "=r" (rsc.value));
     
    238222        rsc.be = false;
    239223        rsc.pl = PL_USER;
    240         rsc.mode = 3;                           /* eager mode */
     224        rsc.mode = 3;                   /* eager mode */
    241225
    242226        switch_to_userspace((uintptr_t) kernel_uarg->uspace_entry,
    243                             ((uintptr_t) kernel_uarg->uspace_stack)+PAGE_SIZE-ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT),
    244                             ((uintptr_t) kernel_uarg->uspace_stack)+PAGE_SIZE,
    245                             (uintptr_t) kernel_uarg->uspace_uarg,
    246                             psr.value, rsc.value);
    247 
    248         while (1) {
     227            ((uintptr_t) kernel_uarg->uspace_stack) + PAGE_SIZE -
     228            ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT),
     229            ((uintptr_t) kernel_uarg->uspace_stack) + PAGE_SIZE,
     230            (uintptr_t) kernel_uarg->uspace_uarg, psr.value, rsc.value);
     231
     232        while (1)
    249233                ;
    250         }
    251234}
    252235
     
    268251        ski_kbd_grab();
    269252#else
    270         #ifdef CONFIG_NS16550
    271                 ns16550_grab();
    272         #else
    273                 i8042_grab();
    274         #endif 
    275 #endif 
    276 }
     253#ifdef CONFIG_NS16550
     254        ns16550_grab();
     255#else
     256        i8042_grab();
     257#endif 
     258#endif 
     259}
     260
    277261/** Return console to userspace
    278262 *
     
    283267        ski_kbd_release();
    284268#else   
    285         #ifdef CONFIG_NS16550
    286                 ns16550_release();
    287         #else   
    288                 i8042_release();
    289         #endif 
    290 
     269#ifdef CONFIG_NS16550
     270        ns16550_release();
     271#else   
     272        i8042_release();
     273#endif 
    291274#endif
    292275}
     
    294277void arch_reboot(void)
    295278{
    296         outb(0x64,0xfe);
    297         while (1);
     279        outb(0x64, 0xfe);
     280        while (1)
     281                ;
    298282}
    299283
  • kernel/arch/ia64/src/interrupt.c

    rd8c0dc5 r666773c  
    245245{
    246246        cr_ivr_t ivr;
     247        irq_t *irq;
    247248       
    248249        ivr.value = ivr_read();
    249250        srlz_d();
    250251
    251                 switch (ivr.vector) {
    252                 case INTERRUPT_SPURIOUS:
     252        switch (ivr.vector) {
     253        case INTERRUPT_SPURIOUS:
    253254#ifdef CONFIG_DEBUG
    254                         printf("cpu%d: spurious interrupt\n", CPU->id);
     255                printf("cpu%d: spurious interrupt\n", CPU->id);
    255256#endif
    256                         break;
     257                break;
    257258
    258259#ifdef CONFIG_SMP
    259                 case VECTOR_TLB_SHOOTDOWN_IPI:
    260                         tlb_shootdown_ipi_recv();
     260        case VECTOR_TLB_SHOOTDOWN_IPI:
     261                tlb_shootdown_ipi_recv();
     262                end_of_local_irq();
     263                break;
     264#endif
     265
     266        case INTERRUPT_TIMER:
     267                irq = irq_dispatch_and_lock(ivr.vector);
     268                if (irq) {
     269                        irq->handler(irq, irq->arg);
     270                        spinlock_unlock(&irq->lock);
     271                } else {
     272                        panic("\nUnhandled Internal Timer Interrupt (%d)\n",
     273                            ivr.vector);
     274                }
     275                break;
     276        default:
     277                irq = irq_dispatch_and_lock(ivr.vector);
     278                if (irq) {
     279                        /*
     280                         * The IRQ handler was found.
     281                         */
     282                        if (irq->preack) {
     283                                /* Send EOI before processing the interrupt */
     284                                end_of_local_irq();
     285                        }
     286                        irq->handler(irq, irq->arg);
     287                        if (!irq->preack)
     288                                end_of_local_irq();
     289                        spinlock_unlock(&irq->lock);
     290                } else {
     291                        /*
     292                         * Unhandled interrupt.
     293                         */
    261294                        end_of_local_irq();
    262                         break;
     295#ifdef CONFIG_DEBUG
     296                        printf("\nUnhandled External Interrupt Vector %d\n",
     297                            ivr.vector);
    263298#endif
    264 
    265                 case INTERRUPT_TIMER:
    266                         {
    267 
    268                                 irq_t *irq = irq_dispatch_and_lock(ivr.vector);
    269                                 if (irq) {
    270                                         irq->handler(irq, irq->arg);
    271                                         spinlock_unlock(&irq->lock);
    272                                 } else {
    273                                         panic("\nUnhandled Internal Timer Interrupt (%d)\n",ivr.vector);
    274                                 }
    275                         }       
    276                         break;
    277                                
    278                 default:
    279                         {
    280 
    281                                 int ack=false;
    282                                 irq_t *irq = irq_dispatch_and_lock(ivr.vector);
    283                                 if (irq) {
    284                                         /*
    285                                          * The IRQ handler was found.
    286                                          */
    287                  
    288                                         if (irq->preack) {
    289                                                 /* Send EOI before processing the interrupt */
    290                                                 end_of_local_irq();
    291                                                 ack=true;
    292                                         }
    293                                         irq->handler(irq, irq->arg);
    294                                         spinlock_unlock(&irq->lock);
    295                                 } else {
    296                                         /*
    297                                          * Unhandled interrupt.
    298                                          */
    299                                         end_of_local_irq();
    300                                         ack=true;
    301 #ifdef CONFIG_DEBUG
    302                                         printf("\nUnhandled External Interrupt Vector %d\n",ivr.vector);
    303 #endif
    304                                 }
    305                                 if(!ack) end_of_local_irq();
    306 
    307                         }       
    308 
    309 
    310                         break;
    311299                }
     300                break;
     301        }
    312302}
    313303
  • kernel/arch/ia64/src/mm/as.c

    rd8c0dc5 r666773c  
    6969               
    7070                rr.word = rr_read(i);
    71                 rr.map.ve = false;                      /* disable VHPT walker */
     71                rr.map.ve = false;              /* disable VHPT walker */
    7272                rr.map.rid = ASID2RID(as->asid, i);
    7373                rr.map.ps = PAGE_WIDTH;
  • kernel/arch/ia64/src/mm/page.c

    rd8c0dc5 r666773c  
    124124 * Interrupts must be disabled.
    125125 *
    126  * @param page Address of virtual page including VRN bits.
    127  * @param asid Address space identifier.
    128  *
    129  * @return VHPT entry address.
     126 * @param page          Address of virtual page including VRN bits.
     127 * @param asid          Address space identifier.
     128 *
     129 * @return              VHPT entry address.
    130130 */
    131131vhpt_entry_t *vhpt_hash(uintptr_t page, asid_t asid)
     
    168168 * Interrupts must be disabled.
    169169 *
    170  * @param page Address of virtual page including VRN bits.
    171  * @param asid Address space identifier.
    172  *
    173  * @return True if page and asid match the page and asid of t, false otherwise.
     170 * @param page          Address of virtual page including VRN bits.
     171 * @param asid          Address space identifier.
     172 *
     173 * @return              True if page and asid match the page and asid of t,
     174 *                      false otherwise.
    174175 */
    175176bool vhpt_compare(uintptr_t page, asid_t asid, vhpt_entry_t *v)
     
    212213 *
    213214 * @param v VHPT entry to be set up.
    214  * @param page Virtual address of the page mapped by the entry.
    215  * @param asid Address space identifier of the address space to which page belongs.
    216  * @param frame Physical address of the frame to wich page is mapped.
    217  * @param flags Different flags for the mapping.
    218  */
    219 void vhpt_set_record(vhpt_entry_t *v, uintptr_t page, asid_t asid, uintptr_t frame, int flags)
     215 * @param page          Virtual address of the page mapped by the entry.
     216 * @param asid          Address space identifier of the address space to which
     217 *                      page belongs.
     218 * @param frame         Physical address of the frame to wich page is mapped.
     219 * @param flags         Different flags for the mapping.
     220 */
     221void
     222vhpt_set_record(vhpt_entry_t *v, uintptr_t page, asid_t asid, uintptr_t frame,
     223    int flags)
    220224{
    221225        region_register rr_save, rr;   
     
    251255       
    252256        v->present.p = true;
    253         v->present.ma = (flags & PAGE_CACHEABLE) ? MA_WRITEBACK : MA_UNCACHEABLE;
     257        v->present.ma = (flags & PAGE_CACHEABLE) ?
     258            MA_WRITEBACK : MA_UNCACHEABLE;
    254259        v->present.a = false;   /* not accessed */
    255260        v->present.d = false;   /* not dirty */
     
    266271extern uintptr_t last_frame;
    267272
    268 
    269273uintptr_t hw_map(uintptr_t physaddr, size_t size)
    270274{
    271         if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
    272                 panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
     275        if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
     276            KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
     277                panic("Unable to map physical memory %p (%d bytes)", physaddr,
     278                    size)
    273279       
    274280        uintptr_t virtaddr = PA2KA(last_frame);
     
    276282        for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
    277283                uintptr_t addr = PFN2ADDR(i);
    278                 page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr, PAGE_NOT_CACHEABLE | PAGE_WRITE);
     284                page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr,
     285                    PAGE_NOT_CACHEABLE | PAGE_WRITE);
    279286        }
    280287       
     
    284291}
    285292
    286 
    287 
    288293/** @}
    289294 */
  • kernel/arch/ia64/src/mm/tlb.c

    rd8c0dc5 r666773c  
    9393/** Invalidate entries belonging to an address space.
    9494 *
    95  * @param asid Address space identifier.
     95 * @param asid          Address space identifier.
    9696 */
    9797void tlb_invalidate_asid(asid_t asid)
     
    132132       
    133133        switch (b) {
    134         case 0: /*cnt 1-3*/
     134        case 0: /* cnt 1 - 3 */
    135135                ps = PAGE_WIDTH;
    136136                break;
    137         case 1: /*cnt 4-15*/
    138                 ps = PAGE_WIDTH+2;
    139                 va &= ~((1<<ps)-1);
    140                 break;
    141         case 2: /*cnt 16-63*/
    142                 ps = PAGE_WIDTH+4;
    143                 va &= ~((1<<ps)-1);
    144                 break;
    145         case 3: /*cnt 64-255*/
    146                 ps = PAGE_WIDTH+6;
    147                 va &= ~((1<<ps)-1);
    148                 break;
    149         case 4: /*cnt 256-1023*/
    150                 ps = PAGE_WIDTH+8;
    151                 va &= ~((1<<ps)-1);
    152                 break;
    153         case 5: /*cnt 1024-4095*/
    154                 ps = PAGE_WIDTH+10;
    155                 va &= ~((1<<ps)-1);
    156                 break;
    157         case 6: /*cnt 4096-16383*/
    158                 ps = PAGE_WIDTH+12;
    159                 va &= ~((1<<ps)-1);
    160                 break;
    161         case 7: /*cnt 16384-65535*/
    162         case 8: /*cnt 65536-(256K-1)*/
    163                 ps = PAGE_WIDTH+14;
    164                 va &= ~((1<<ps)-1);
     137        case 1: /* cnt 4 - 15 */
     138                ps = PAGE_WIDTH + 2;
     139                va &= ~((1 << ps) - 1);
     140                break;
     141        case 2: /* cnt 16 - 63 */
     142                ps = PAGE_WIDTH + 4;
     143                va &= ~((1 << ps) - 1);
     144                break;
     145        case 3: /* cnt 64 - 255 */
     146                ps = PAGE_WIDTH + 6;
     147                va &= ~((1 << ps) - 1);
     148                break;
     149        case 4: /* cnt 256 - 1023 */
     150                ps = PAGE_WIDTH + 8;
     151                va &= ~((1 << ps) - 1);
     152                break;
     153        case 5: /* cnt 1024 - 4095 */
     154                ps = PAGE_WIDTH + 10;
     155                va &= ~((1 << ps) - 1);
     156                break;
     157        case 6: /* cnt 4096 - 16383 */
     158                ps = PAGE_WIDTH + 12;
     159                va &= ~((1 << ps) - 1);
     160                break;
     161        case 7: /* cnt 16384 - 65535 */
     162        case 8: /* cnt 65536 - (256K - 1) */
     163                ps = PAGE_WIDTH + 14;
     164                va &= ~((1 << ps) - 1);
    165165                break;
    166166        default:
    167                 ps=PAGE_WIDTH+18;
    168                 va&=~((1<<ps)-1);
    169                 break;
    170         }
    171         for(; va<(page+cnt*(PAGE_SIZE)); va += (1<<ps)) {
    172                 asm volatile (
    173                         "ptc.l %0,%1;;"
    174                         :
    175                         : "r" (va), "r" (ps<<2)
    176                 );
    177         }
     167                ps = PAGE_WIDTH + 18;
     168                va &= ~((1 << ps) - 1);
     169                break;
     170        }
     171        for(; va < (page + cnt * PAGE_SIZE); va += (1 << ps))
     172                asm volatile ("ptc.l %0, %1;;" :: "r" (va), "r" (ps << 2));
    178173        srlz_d();
    179174        srlz_i();
     
    188183/** Insert data into data translation cache.
    189184 *
    190  * @param va Virtual page address.
    191  * @param asid Address space identifier.
    192  * @param entry The rest of TLB entry as required by TLB insertion format.
     185 * @param va            Virtual page address.
     186 * @param asid          Address space identifier.
     187 * @param entry         The rest of TLB entry as required by TLB insertion
     188 *                      format.
    193189 */
    194190void dtc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
     
    199195/** Insert data into instruction translation cache.
    200196 *
    201  * @param va Virtual page address.
    202  * @param asid Address space identifier.
    203  * @param entry The rest of TLB entry as required by TLB insertion format.
     197 * @param va            Virtual page address.
     198 * @param asid          Address space identifier.
     199 * @param entry         The rest of TLB entry as required by TLB insertion
     200 *                      format.
    204201 */
    205202void itc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
     
    210207/** Insert data into instruction or data translation cache.
    211208 *
    212  * @param va Virtual page address.
    213  * @param asid Address space identifier.
    214  * @param entry The rest of TLB entry as required by TLB insertion format.
    215  * @param dtc If true, insert into data translation cache, use instruction translation cache otherwise.
     209 * @param va            Virtual page address.
     210 * @param asid          Address space identifier.
     211 * @param entry         The rest of TLB entry as required by TLB insertion
     212 *                      format.
     213 * @param dtc           If true, insert into data translation cache, use
     214 *                      instruction translation cache otherwise.
    216215 */
    217216void tc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtc)
     
    236235       
    237236        asm volatile (
    238                 "mov r8=psr;;\n"
     237                "mov r8 = psr;;\n"
    239238                "rsm %0;;\n"                    /* PSR_IC_MASK */
    240239                "srlz.d;;\n"
    241240                "srlz.i;;\n"
    242                 "mov cr.ifa=%1\n"               /* va */
    243                 "mov cr.itir=%2;;\n"            /* entry.word[1] */
    244                 "cmp.eq p6,p7 = %4,r0;;\n"      /* decide between itc and dtc */ 
     241                "mov cr.ifa = %1\n"             /* va */
     242                "mov cr.itir = %2;;\n"          /* entry.word[1] */
     243                "cmp.eq p6,p7 = %4,r0;;\n"      /* decide between itc and dtc */
    245244                "(p6) itc.i %3;;\n"
    246245                "(p7) itc.d %3;;\n"
    247                 "mov psr.l=r8;;\n"
     246                "mov psr.l = r8;;\n"
    248247                "srlz.d;;\n"
    249248                :
    250                 : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]), "r" (entry.word[0]), "r" (dtc)
     249                : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]),
     250                    "r" (entry.word[0]), "r" (dtc)
    251251                : "p6", "p7", "r8"
    252252        );
     
    261261/** Insert data into instruction translation register.
    262262 *
    263  * @param va Virtual page address.
    264  * @param asid Address space identifier.
    265  * @param entry The rest of TLB entry as required by TLB insertion format.
    266  * @param tr Translation register.
    267  */
    268 void itr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, index_t tr)
     263 * @param va            Virtual page address.
     264 * @param asid          Address space identifier.
     265 * @param entry         The rest of TLB entry as required by TLB insertion
     266 *                      format.
     267 * @param tr            Translation register.
     268 */
     269void
     270itr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, index_t tr)
    269271{
    270272        tr_mapping_insert(va, asid, entry, false, tr);
     
    273275/** Insert data into data translation register.
    274276 *
    275  * @param va Virtual page address.
    276  * @param asid Address space identifier.
    277  * @param entry The rest of TLB entry as required by TLB insertion format.
    278  * @param tr Translation register.
    279  */
    280 void dtr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, index_t tr)
     277 * @param va            Virtual page address.
     278 * @param asid          Address space identifier.
     279 * @param entry         The rest of TLB entry as required by TLB insertion
     280 *                      format.
     281 * @param tr            Translation register.
     282 */
     283void
     284dtr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, index_t tr)
    281285{
    282286        tr_mapping_insert(va, asid, entry, true, tr);
     
    285289/** Insert data into instruction or data translation register.
    286290 *
    287  * @param va Virtual page address.
    288  * @param asid Address space identifier.
    289  * @param entry The rest of TLB entry as required by TLB insertion format.
    290  * @param dtr If true, insert into data translation register, use instruction translation register otherwise.
    291  * @param tr Translation register.
    292  */
    293 void tr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtr, index_t tr)
     291 * @param va            Virtual page address.
     292 * @param asid          Address space identifier.
     293 * @param entry         The rest of TLB entry as required by TLB insertion
     294 *                      format.
     295 * @param dtr           If true, insert into data translation register, use
     296 *                      instruction translation register otherwise.
     297 * @param tr            Translation register.
     298 */
     299void
     300tr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtr,
     301    index_t tr)
    294302{
    295303        region_register rr;
     
    312320
    313321        asm volatile (
    314                 "mov r8=psr;;\n"
     322                "mov r8 = psr;;\n"
    315323                "rsm %0;;\n"                    /* PSR_IC_MASK */
    316324                "srlz.d;;\n"
    317325                "srlz.i;;\n"
    318                 "mov cr.ifa=%1\n"               /* va */                 
    319                 "mov cr.itir=%2;;\n"            /* entry.word[1] */
    320                 "cmp.eq p6,p7=%5,r0;;\n"        /* decide between itr and dtr */
    321                 "(p6) itr.i itr[%4]=%3;;\n"
    322                 "(p7) itr.d dtr[%4]=%3;;\n"
    323                 "mov psr.l=r8;;\n"
     326                "mov cr.ifa = %1\n"             /* va */                 
     327                "mov cr.itir = %2;;\n"          /* entry.word[1] */
     328                "cmp.eq p6,p7 = %5,r0;;\n"      /* decide between itr and dtr */
     329                "(p6) itr.i itr[%4] = %3;;\n"
     330                "(p7) itr.d dtr[%4] = %3;;\n"
     331                "mov psr.l = r8;;\n"
    324332                "srlz.d;;\n"
    325333                :
    326                 : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]), "r" (entry.word[0]), "r" (tr), "r" (dtr)
     334                : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]),
     335                    "r" (entry.word[0]), "r" (tr), "r" (dtr)
    327336                : "p6", "p7", "r8"
    328337        );
     
    337346/** Insert data into DTLB.
    338347 *
    339  * @param page Virtual page address including VRN bits.
    340  * @param frame Physical frame address.
    341  * @param dtr If true, insert into data translation register, use data translation cache otherwise.
    342  * @param tr Translation register if dtr is true, ignored otherwise.
    343  */
    344 void dtlb_kernel_mapping_insert(uintptr_t page, uintptr_t frame, bool dtr, index_t tr)
     348 * @param page          Virtual page address including VRN bits.
     349 * @param frame         Physical frame address.
     350 * @param dtr           If true, insert into data translation register, use data
     351 *                      translation cache otherwise.
     352 * @param tr            Translation register if dtr is true, ignored otherwise.
     353 */
     354void
     355dtlb_kernel_mapping_insert(uintptr_t page, uintptr_t frame, bool dtr,
     356    index_t tr)
    345357{
    346358        tlb_entry_t entry;
     
    368380 * Purge DTR entries used by the kernel.
    369381 *
    370  * @param page Virtual page address including VRN bits.
    371  * @param width Width of the purge in bits.
     382 * @param page          Virtual page address including VRN bits.
     383 * @param width         Width of the purge in bits.
    372384 */
    373385void dtr_purge(uintptr_t page, count_t width)
    374386{
    375         asm volatile ("ptr.d %0, %1\n" : : "r" (page), "r" (width<<2));
     387        asm volatile ("ptr.d %0, %1\n" : : "r" (page), "r" (width << 2));
    376388}
    377389
     
    379391/** Copy content of PTE into data translation cache.
    380392 *
    381  * @param t PTE.
     393 * @param t             PTE.
    382394 */
    383395void dtc_pte_copy(pte_t *t)
     
    405417/** Copy content of PTE into instruction translation cache.
    406418 *
    407  * @param t PTE.
     419 * @param t             PTE.
    408420 */
    409421void itc_pte_copy(pte_t *t)
     
    432444/** Instruction TLB fault handler for faults with VHPT turned off.
    433445 *
    434  * @param vector Interruption vector.
    435  * @param istate Structure with saved interruption state.
     446 * @param vector                Interruption vector.
     447 * @param istate                Structure with saved interruption state.
    436448 */
    437449void alternate_instruction_tlb_fault(uint64_t vector, istate_t *istate)
     
    462474                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    463475                        fault_if_from_uspace(istate,"Page fault at %p",va);
    464                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid, istate->cr_iip);
    465                 }
    466         }
    467 }
    468 
    469 
     476                        panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     477                            istate->cr_iip);
     478                }
     479        }
     480}
    470481
    471482static int is_io_page_accessible(int page)
    472483{
    473         if(TASK->arch.iomap) return bitmap_get(TASK->arch.iomap,page);
    474         else return 0;
     484        if (TASK->arch.iomap)
     485                return bitmap_get(TASK->arch.iomap,page);
     486        else
     487                return 0;
    475488}
    476489
    477490#define IO_FRAME_BASE 0xFFFFC000000
    478491
    479 /** There is special handling of memmaped lagacy io, because
    480  * of 4KB sized access
    481  * only for userspace
    482  *
    483  * @param va virtual address of page fault
    484  * @param istate Structure with saved interruption state.
    485  *
    486  *
    487  * @return 1 on success, 0 on fail
     492/**
     493 * There is special handling of memory mapped legacy io, because of 4KB sized
     494 * access for userspace.
     495 *
     496 * @param va            Virtual address of page fault.
     497 * @param istate        Structure with saved interruption state.
     498 *
     499 * @return              One on success, zero on failure.
    488500 */
    489501static int try_memmap_io_insertion(uintptr_t va, istate_t *istate)
    490502{
    491         if((va >= IO_OFFSET ) && (va < IO_OFFSET + (1<<IO_PAGE_WIDTH)))
    492                 if(TASK){
    493                        
    494                         uint64_t io_page=(va &  ((1<<IO_PAGE_WIDTH)-1)) >> (USPACE_IO_PAGE_WIDTH);
    495                         if(is_io_page_accessible(io_page)){
    496                                 uint64_t page,frame;
    497 
    498                                 page = IO_OFFSET + (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    499                                 frame = IO_FRAME_BASE + (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    500 
     503        if ((va >= IO_OFFSET ) && (va < IO_OFFSET + (1 << IO_PAGE_WIDTH))) {
     504                if (TASK) {
     505                        uint64_t io_page = (va & ((1 << IO_PAGE_WIDTH) - 1)) >>
     506                            USPACE_IO_PAGE_WIDTH;
     507
     508                        if (is_io_page_accessible(io_page)) {
     509                                uint64_t page, frame;
     510
     511                                page = IO_OFFSET +
     512                                    (1 << USPACE_IO_PAGE_WIDTH) * io_page;
     513                                frame = IO_FRAME_BASE +
     514                                    (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    501515
    502516                                tlb_entry_t entry;
     
    505519                                entry.word[1] = 0;
    506520       
    507                                 entry.p = true;                 /* present */
     521                                entry.p = true;         /* present */
    508522                                entry.ma = MA_UNCACHEABLE;             
    509                                 entry.a = true;                 /* already accessed */
    510                                 entry.d = true;                 /* already dirty */
     523                                entry.a = true;         /* already accessed */
     524                                entry.d = true;         /* already dirty */
    511525                                entry.pl = PL_USER;
    512526                                entry.ar = AR_READ | AR_WRITE;
     
    516530                                dtc_mapping_insert(page, TASK->as->asid, entry);
    517531                                return 1;
    518                         }else {
    519                                 fault_if_from_uspace(istate,"IO access fault at %p",va);
    520                                 return 0;
    521                         }               
    522                 } else
    523                         return 0;
    524         else
    525                 return 0;
     532                        } else {
     533                                fault_if_from_uspace(istate,
     534                                    "IO access fault at %p", va);
     535                        }
     536                }
     537        }
    526538               
    527539        return 0;
    528 
    529 }
    530 
    531 
    532 
     540}
    533541
    534542/** Data TLB fault handler for faults with VHPT turned off.
    535543 *
    536  * @param vector Interruption vector.
    537  * @param istate Structure with saved interruption state.
     544 * @param vector        Interruption vector.
     545 * @param istate        Structure with saved interruption state.
    538546 */
    539547void alternate_data_tlb_fault(uint64_t vector, istate_t *istate)
     
    569577        } else {
    570578                page_table_unlock(AS, true);
    571                 if (try_memmap_io_insertion(va,istate)) return;
    572                 /*
    573                  * Forward the page fault to the address space page fault handler.
     579                if (try_memmap_io_insertion(va, istate))
     580                        return;
     581                /*
     582                 * Forward the page fault to the address space page fault
     583                 * handler.
    574584                 */
    575585                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    576586                        fault_if_from_uspace(istate,"Page fault at %p",va);
    577                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid, istate->cr_iip);
     587                        panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     588                            istate->cr_iip);
    578589                }
    579590        }
     
    584595 * This fault should not occur.
    585596 *
    586  * @param vector Interruption vector.
    587  * @param istate Structure with saved interruption state.
     597 * @param vector        Interruption vector.
     598 * @param istate        Structure with saved interruption state.
    588599 */
    589600void data_nested_tlb_fault(uint64_t vector, istate_t *istate)
     
    594605/** Data Dirty bit fault handler.
    595606 *
    596  * @param vector Interruption vector.
    597  * @param istate Structure with saved interruption state.
     607 * @param vector        Interruption vector.
     608 * @param istate        Structure with saved interruption state.
    598609 */
    599610void data_dirty_bit_fault(uint64_t vector, istate_t *istate)
     
    621632                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    622633                        fault_if_from_uspace(istate,"Page fault at %p",va);
    623                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid, istate->cr_iip);
    624                         t->d = true;
    625                         dtc_pte_copy(t);
     634                        panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     635                            istate->cr_iip);
    626636                }
    627637        }
     
    631641/** Instruction access bit fault handler.
    632642 *
    633  * @param vector Interruption vector.
    634  * @param istate Structure with saved interruption state.
     643 * @param vector        Interruption vector.
     644 * @param istate        Structure with saved interruption state.
    635645 */
    636646void instruction_access_bit_fault(uint64_t vector, istate_t *istate)
     
    657667        } else {
    658668                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    659                         fault_if_from_uspace(istate,"Page fault at %p",va);
    660                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid, istate->cr_iip);
    661                         t->a = true;
    662                         itc_pte_copy(t);
     669                        fault_if_from_uspace(istate, "Page fault at %p", va);
     670                        panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     671                            istate->cr_iip);
    663672                }
    664673        }
     
    694703        } else {
    695704                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    696                         fault_if_from_uspace(istate,"Page fault at %p",va);
    697                         panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid, istate->cr_iip);
    698                         t->a = true;
    699                         itc_pte_copy(t);
     705                        fault_if_from_uspace(istate, "Page fault at %p", va);
     706                        panic("%s: va=%p, rid=%d, iip=%p\n", __func__, va, rid,
     707                            istate->cr_iip);
    700708                }
    701709        }
     
    736744                page_table_unlock(AS, true);
    737745                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    738                         fault_if_from_uspace(istate,"Page fault at %p",va);
     746                        fault_if_from_uspace(istate, "Page fault at %p", va);
    739747                        panic("%s: va=%p, rid=%d\n", __func__, va, rid);
    740748                }
  • kernel/arch/ia64/src/mm/vhpt.c

    rd8c0dc5 r666773c  
    4242uintptr_t vhpt_set_up(void)
    4343{
    44         vhpt_base = frame_alloc(VHPT_WIDTH - FRAME_WIDTH, FRAME_KA | FRAME_ATOMIC);
     44        vhpt_base = frame_alloc(VHPT_WIDTH - FRAME_WIDTH,
     45            FRAME_KA | FRAME_ATOMIC);
    4546        if (!vhpt_base)
    4647                panic("Kernel configured with VHPT but no memory for table.");
  • kernel/arch/ia64/src/proc/scheduler.c

    rd8c0dc5 r666773c  
    4848}
    4949
    50 /** Prepare kernel stack pointers in bank 0 r22 and r23 and make sure the stack is mapped in DTR. */
     50/** Prepare kernel stack pointers in bank 0 r22 and r23 and make sure the stack
     51 * is mapped in DTR.
     52 */
    5153void before_thread_runs_arch(void)
    5254{
    5355        uintptr_t base;
    5456       
    55         base = ALIGN_DOWN(config.base, 1<<KERNEL_PAGE_WIDTH);
     57        base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    5658
    57         if ((uintptr_t) THREAD->kstack < base || (uintptr_t) THREAD->kstack > base + (1<<(KERNEL_PAGE_WIDTH))) {
     59        if ((uintptr_t) THREAD->kstack < base ||
     60            (uintptr_t) THREAD->kstack > base + (1 << (KERNEL_PAGE_WIDTH))) {
    5861                /*
    5962                 * Kernel stack of this thread is not mapped by DTR[TR_KERNEL].
     
    6568               
    6669                /* insert DTR[TR_STACK1] and DTR[TR_STACK2] */
    67                 dtlb_kernel_mapping_insert((uintptr_t) THREAD->kstack, KA2PA(THREAD->kstack), true, DTR_KSTACK1);
    68                 dtlb_kernel_mapping_insert((uintptr_t) THREAD->kstack + PAGE_SIZE, KA2PA(THREAD->kstack) + FRAME_SIZE, true, DTR_KSTACK2);
     70                dtlb_kernel_mapping_insert((uintptr_t) THREAD->kstack,
     71                    KA2PA(THREAD->kstack), true, DTR_KSTACK1);
     72                dtlb_kernel_mapping_insert((uintptr_t) THREAD->kstack +
     73                    PAGE_SIZE, KA2PA(THREAD->kstack) + FRAME_SIZE, true,
     74                    DTR_KSTACK2);
    6975        }
    7076       
  • kernel/arch/ia64/src/ski/ski.c

    rd8c0dc5 r666773c  
    119119        while(!(ch = ski_getchar()))
    120120                ;
    121         if(ch == '\r')
     121        if (ch == '\r')
    122122                ch = '\n';
    123123        return (char) ch;
     
    144144                ch = '\n';
    145145        if (ch) {
    146                 if (ski_kbd_irq.notif_cfg.notify && ski_kbd_irq.notif_cfg.answerbox) {
     146                if (ski_kbd_irq.notif_cfg.notify &&
     147                    ski_kbd_irq.notif_cfg.answerbox) {
    147148                        chardev_push_character(&ski_uconsole, ch);
    148149                        ipc_irq_send_notif(&ski_kbd_irq);
     
    157158
    158159        if (last) {
    159                 if (ski_kbd_irq.notif_cfg.notify && ski_kbd_irq.notif_cfg.answerbox) {
     160                if (ski_kbd_irq.notif_cfg.notify &&
     161                    ski_kbd_irq.notif_cfg.answerbox) {
    160162                        chardev_push_character(&ski_uconsole, 0);
    161163                        ipc_irq_send_notif(&ski_kbd_irq);
  • kernel/arch/ia64/src/smp/smp.c

    rd8c0dc5 r666773c  
    6262#include <print.h>
    6363
    64 
    65 
    66 
    67 
    68 
    6964#ifdef CONFIG_SMP
    70 
    7165
    7266extern char cpu_by_id_eid_list[256][256];
    7367
    74 
    7568static void sapic_init(void)
    7669{
    77         bootinfo->sapic=(unative_t *)(PA2KA((unative_t)(bootinfo->sapic))|FW_OFFSET);
     70        bootinfo->sapic = (unative_t *)(PA2KA((unative_t)(bootinfo->sapic)) |
     71            FW_OFFSET);
    7872}
    7973
    80 
    81 
    82 static void ipi_broadcast_arch_all(int ipi )
     74static void ipi_broadcast_arch_all(int ipi)
    8375{
    8476        int id,eid;
    85         int myid,myeid;
     77        int myid, myeid;
    8678       
    87         myid=ia64_get_cpu_id();
    88         myeid=ia64_get_cpu_eid();
    89 
     79        myid = ia64_get_cpu_id();
     80        myeid = ia64_get_cpu_eid();
    9081       
    91         for(id=0;id<256;id++)
    92                 for(eid=0;eid<256;eid++)
    93                         if((id!=myid) || (eid!=myeid))
    94                                 ipi_send_ipi(id,eid,ipi);
     82        for (id = 0; id < 256; id++)
     83                for (eid = 0; eid < 256; eid++)
     84                        if ((id != myid) || (eid != myeid))
     85                                ipi_send_ipi(id, eid, ipi);
    9586}
    9687
     
    10091        int myid,myeid;
    10192       
    102         myid=ia64_get_cpu_id();
    103         myeid=ia64_get_cpu_eid();
     93        myid = ia64_get_cpu_id();
     94        myeid = ia64_get_cpu_eid();
    10495
    105         for(id=0;id<256;id++)
    106                 for(eid=0;eid<256;eid++)
    107                         if((id!=myid) || (eid!=myeid))
    108                                 if(cpu_by_id_eid_list[id][eid])
    109                                         ipi_send_ipi(id,eid,ipi);
    110 
     96        for (id = 0; id < 256; id++)
     97                for (eid = 0; eid < 256; eid++)
     98                        if ((id != myid) || (eid != myeid))
     99                                if (cpu_by_id_eid_list[id][eid])
     100                                        ipi_send_ipi(id, eid, ipi);
    111101}
    112 
    113102
    114103void smp_init(void)
    115104{
    116         if(!bootinfo->hello_configured) return;
    117         //If we have not system prepared by hello, we are not able to start AP's
    118         //this means we are running on simulator
     105        if (!bootinfo->hello_configured)
     106                return;
     107       
     108        /*
     109         * If we have not system prepared by hello, we are not able to start
     110         * AP's. This means we are running on a simulator.
     111         */
    119112       
    120113        sapic_init();
    121114        ipi_broadcast_arch_all(bootinfo->wakeup_intno);
    122115        volatile long long brk;
    123         for(brk=0;brk<100LL*1024LL*1024LL;brk++); //wait a while before CPUs starts
     116        for (brk = 0; brk < 100LL * 1024LL * 1024LL; brk++)
     117                ;       /* wait a while before CPUs starts */
    124118
    125         config.cpu_count=0;
    126         int id,eid;
     119        config.cpu_count = 0;
     120        int id, eid;
    127121       
    128         for(id=0;id<256;id++)
    129                 for(eid=0;eid<256;eid++)
    130                         if(cpu_by_id_eid_list[id][eid]==1){
     122        for (id = 0; id < 256; id++)
     123                for (eid = 0; eid < 256; eid++)
     124                        if (cpu_by_id_eid_list[id][eid] == 1) {
    131125                                config.cpu_count++;
    132                                 cpu_by_id_eid_list[id][eid]=2;
    133 
     126                                cpu_by_id_eid_list[id][eid] = 2;
    134127                        }
    135128}
    136 
    137129
    138130void kmp(void *arg __attribute__((unused)))
    139131{
    140132        int id,eid;
    141         int myid,myeid;
     133        int myid, myeid;
    142134       
    143         myid=ia64_get_cpu_id();
    144         myeid=ia64_get_cpu_eid();
     135        myid = ia64_get_cpu_id();
     136        myeid = ia64_get_cpu_eid();
    145137
    146         for(id=0;id<256;id++)
    147                 for(eid=0;eid<256;eid++)
    148                         if((id!=myid) || (eid!=myeid))
    149                                 if(cpu_by_id_eid_list[id][eid]!=0){
    150                                         if(cpu_by_id_eid_list[id][eid]==1){
    151                                                 printf("Found Late CPU ID:%d EDI:%d Not added to system!!!\n",id,eid);
     138        for (id = 0; id < 256; id++)
     139                for (eid = 0; eid < 256; eid++)
     140                        if ((id != myid) || (eid != myeid))
     141                                if (cpu_by_id_eid_list[id][eid] != 0) {
     142                                        if (cpu_by_id_eid_list[id][eid] == 1) {
     143                                                printf("Found Late CPU ID:%d "
     144                                                    "EDI:%d Not added to "
     145                                                    "system!!!\n", id, eid);
    152146                                                continue;
    153                                                 }
    154                                         cpu_by_id_eid_list[id][eid]=3;
     147                                        }
     148                                        cpu_by_id_eid_list[id][eid] = 3;
    155149                                        /*
    156                                          * There may be just one AP being initialized at
    157                                          * the time. After it comes completely up, it is
     150                                         * There may be just one AP being
     151                                         * initialized at the time. After
     152                                         * it comes completely up, it is
    158153                                         * supposed to wake us up.
    159154                                         */
    160                                         if (waitq_sleep_timeout(&ap_completion_wq, 1000000,
    161                                             SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) {
    162                                                 printf("%s: waiting for cpu ID:%d EID:%d"
    163                                                     "timed out\n", __FUNCTION__,
    164                                                     id, eid);
    165                                             }   
    166                
     155                                        if (waitq_sleep_timeout(
     156                                            &ap_completion_wq, 1000000,
     157                                            SYNCH_FLAGS_NONE) ==
     158                                            ESYNCH_TIMEOUT) {
     159                                                printf("%s: waiting for cpu "
     160                                                    "ID:%d EID:%d timed out\n",
     161                                                    __FUNCTION__, id, eid);
     162                                            }
    167163                                }
    168164}
     165
    169166#endif
    170167
    171168
    172 /*This is just a hack for linking with assembler - may be removed in future*/
    173169#ifndef CONFIG_SMP
     170
     171/* This is just a hack for linking with assembler - may be removed in future. */
    174172void main_ap(void);
    175173void main_ap(void)
    176174{
    177         while(1);
     175        while(1)
     176                ;
    178177}
    179178
  • kernel/arch/ia64/src/start.S

    rd8c0dc5 r666773c  
    3333
    3434#define RR_MASK (0xFFFFFFFF00000002)
    35 #define RID_SHIFT 8
    36 #define PS_SHIFT 2
    37 
    38 #define KERNEL_TRANSLATION_I  0x0010000000000661
    39 #define KERNEL_TRANSLATION_D  0x0010000000000661
    40 #define KERNEL_TRANSLATION_VIO 0x0010000000000671
    41 #define KERNEL_TRANSLATION_IO 0x00100FFFFC000671
    42 #define KERNEL_TRANSLATION_FW 0x00100000F0000671
    43 
    44 
     35#define RID_SHIFT       8
     36#define PS_SHIFT        2
     37
     38#define KERNEL_TRANSLATION_I    0x0010000000000661
     39#define KERNEL_TRANSLATION_D    0x0010000000000661
     40#define KERNEL_TRANSLATION_VIO  0x0010000000000671
     41#define KERNEL_TRANSLATION_IO   0x00100FFFFC000671
     42#define KERNEL_TRANSLATION_FW   0x00100000F0000671
    4543
    4644.section K_TEXT_START, "ax"
     
    5250        .auto
    5351
    54 #identifi self(CPU) in OS structures by ID / EID
    55         mov r9=cr64
    56         mov r10=1
    57         movl r12=0xffffffff
    58         movl r8=cpu_by_id_eid_list
    59         and r8=r8,r12
    60         shr r9=r9,16
    61         add r8=r8,r9
    62         st1 [r8]=r10
    63 
    64 
     52        # Identify self(CPU) in OS structures by ID / EID
     53
     54        mov r9 = cr64
     55        mov r10 = 1
     56        movl r12 = 0xffffffff
     57        movl r8 = cpu_by_id_eid_list
     58        and r8 = r8, r12
     59        shr r9 = r9, 16
     60        add r8 = r8, r9
     61        st1 [r8] = r10
    6562
    6663        mov psr.l = r0
     
    7067        # Fill TR.i and TR.d using Region Register #VRN_KERNEL
    7168
    72 
    7369        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    7470        mov r9 = rr[r8]
    75 
    7671
    7772        movl r10 = (RR_MASK)
     
    8075        or  r9 = r10, r9
    8176
    82 
    8377        mov rr[r8] = r9
    8478
    85 
    86 
    8779        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    8880        mov cr.ifa = r8
    8981
    90        
    9182        mov r11 = cr.itir ;;
    9283        movl r10 = (KERNEL_PAGE_WIDTH << PS_SHIFT);;
    93         or r10 =r10 , r11 ;;
     84        or r10 = r10, r11 ;;
    9485        mov cr.itir = r10;;
    9586
    96        
    9787        movl r10 = (KERNEL_TRANSLATION_I)
    9888        itr.i itr[r0] = r10
    99 
    100        
    10189        movl r10 = (KERNEL_TRANSLATION_D)
    10290        itr.d dtr[r0] = r10
    10391
    104 
    10592        movl r7 = 1
    10693        movl r8 = (VRN_KERNEL << VRN_SHIFT) | VIO_OFFSET
     
    10996        itr.d dtr[r7] = r10
    11097
    111 
    11298        mov r11 = cr.itir ;;
    11399        movl r10 = ~0xfc;;
    114         and r10 =r10 , r11 ;;
     100        and r10 = r10, r11 ;;
    115101        movl r11 = (IO_PAGE_WIDTH << PS_SHIFT);;
    116         or r10 =r10 , r11 ;;
     102        or r10 = r10, r11 ;;
    117103        mov cr.itir = r10;;
    118 
    119104
    120105        movl r7 = 2
     
    124109        itr.d dtr[r7] = r10
    125110
    126 
    127 #setup mapping for fimware arrea (also SAPIC)
     111        # Setup mapping for fimware arrea (also SAPIC)
     112
    128113        mov r11 = cr.itir ;;
    129114        movl r10 = ~0xfc;;
    130         and r10 =r10 , r11 ;;
     115        and r10 = r10, r11 ;;
    131116        movl r11 = (FW_PAGE_WIDTH << PS_SHIFT);;
    132         or r10 =r10 , r11 ;;
     117        or r10 = r10, r11 ;;
    133118        mov cr.itir = r10;;
    134 
    135119
    136120        movl r7 = 3
     
    140124        itr.d dtr[r7] = r10
    141125
    142 
    143 
    144 
    145 
    146         # initialize PSR
     126        # Initialize PSR
     127
    147128        movl r10 = (PSR_DT_MASK | PSR_RT_MASK | PSR_IT_MASK | PSR_IC_MASK)  /* Enable paging */
    148129        mov r9 = psr
     130
    149131        or r10 = r10, r9
    150132        mov cr.ipsr = r10
     
    156138
    157139        .explicit
     140
    158141        /*
    159142         * Return From Interupt is the only the way to fill upper half word of PSR.
     
    161144        rfi;;
    162145
     146
    163147.global paging_start
    164148paging_start:
     
    168152         */
    169153
    170         # switch to register bank 1
     154        # Switch to register bank 1
    171155        bsw.1
    172156
    173 #Am'I BSP or AP
    174         movl r20=bsp_started;;
    175         ld8 r20=[r20];;
    176         cmp.eq p3,p2=r20,r0;;
    177 
     157        # Am I BSP or AP?
     158        movl r20 = bsp_started;;
     159        ld8 r20 = [r20];;
     160        cmp.eq p3, p2 = r20, r0;;
    178161       
    179         # initialize register stack
     162        # Initialize register stack
    180163        mov ar.rsc = r0
    181164        movl r8 = (VRN_KERNEL << VRN_SHIFT) ;;
     
    183166        loadrs
    184167
    185         # initialize memory stack to some sane value
     168        # Initialize memory stack to some sane value
    186169        movl r12 = stack0 ;;
    187        
    188170        add r12 = -16, r12      /* allocate a scratch area on the stack */
    189171
    190         # initialize gp (Global Pointer) register
     172        # Initialize gp (Global Pointer) register
    191173        movl r20 = (VRN_KERNEL << VRN_SHIFT);;
    192174        or r20 = r20,r1;;
     
    217199(p2)    br.call.sptk.many b0 = b1
    218200
    219 #Mark that BSP is on
     201        # Mark that BSP is on
    220202        mov r20=1;;
    221203        movl r21=bsp_started;;
    222204        st8 [r21]=r20;;
    223205
    224 
    225206        br.call.sptk.many b0 = arch_pre_main
    226207
     
    229210        br.call.sptk.many b0 = b1
    230211
    231 
    2322120:
    233213        br 0b
     
    236216kernel_image_ap_start:
    237217        .auto
    238 #identifi self(CPU) in OS structures by ID / EID
    239         mov r9=cr64
    240         mov r10=1
    241         movl r12=0xffffffff
    242         movl r8=cpu_by_id_eid_list
    243         and r8=r8,r12
    244         shr r9=r9,16
    245         add r8=r8,r9
    246         st1 [r8]=r10
     218
     219        # Identify self(CPU) in OS structures by ID / EID
     220
     221        mov r9 = cr64
     222        mov r10 = 1
     223        movl r12 = 0xffffffff
     224        movl r8 = cpu_by_id_eid_list
     225        and r8 = r8, r12
     226        shr r9 = r9, 16
     227        add r8 = r8, r9
     228        st1 [r8] = r10
    247229       
    248 #wait for wakeup sychro signal (#3 in cpu_by_id_eid_list)
     230        # Wait for wakeup synchro signal (#3 in cpu_by_id_eid_list)
    249231kernel_image_ap_start_loop:
    250         movl r11=kernel_image_ap_start_loop
    251         and r11=r11,r12
     232        movl r11 = kernel_image_ap_start_loop
     233        and r11 = r11, r12
    252234        mov b1 = r11
    253235
    254         ld1 r20=[r8];;
    255         movl r21=3;;
    256         cmp.eq p2,p3=r20,r21;;
    257 (p3)br.call.sptk.many b0 = b1
    258 
    259         movl r11=kernel_image_start
    260         and r11=r11,r12
    261     mov b1 = r11
     236        ld1 r20 = [r8];;
     237        movl r21 = 3;;
     238        cmp.eq p2, p3 = r20, r21;;
     239(p3)    br.call.sptk.many b0 = b1
     240
     241        movl r11 = kernel_image_start
     242        and r11 = r11, r12
     243        mov b1 = r11
    262244        br.call.sptk.many b0 = b1
    263245
     
    268250.space 8
    269251
    270 
    271252.align 4096
    272253.global cpu_by_id_eid_list
     
    274255.space 65536
    275256
    276 
Note: See TracChangeset for help on using the changeset viewer.