Changeset 4159


Ignore:
Timestamp:
12/20/09 16:41:41 (3 years ago)
Author:
jylam
Message:
  • Added 64bits RDTSC support, as well as CPU frequency guess (more like a 8254a test, actually)
Location:
libcaca/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • libcaca/trunk/build-kernel

    r4155 r4159  
    1010LDFLAGS="-nostdlib -Wl,-N -Wl,-Ttext -Wl,100000" 
    1111 
    12 ./configure --disable-slang --disable-ncurses --disable-win32 \ 
    13                     --disable-conio --disable-x11 --disable-gl --disable-network \ 
    14                     --enable-vga --disable-imlib2 --disable-doc \ 
    15                     --host i386 
     12#./configure --disable-slang --disable-ncurses --disable-win32 \ 
     13#                   --disable-conio --disable-x11 --disable-gl --disable-network \ 
     14#                   --enable-vga --disable-imlib2 --disable-doc \ 
     15#                   --host i386 
    1616 
    1717# Compile cacademo, leave it as an object 

  • libcaca/trunk/kernel/drivers/processor.c

    r4158 r4159  
    1717#include "kernel.h" 
    1818#include "klibc.h" 
     19#include "drivers/timer.h" 
    1920#include "processor.h" 
    2021 
    … …  
    5051    processor_info->features = a; 
    5152 
     53    processor_info->frequency = 0; 
     54    processor_info->frequency = processor_get_frequency(processor_info); 
     55 
    5256    return 0; 
     57} 
     58 
     59u32 processor_get_frequency(struct processor_info * processor_info) 
     60{ 
     61    if (processor_info->frequency) 
     62        return processor_info->frequency; 
     63    u64 srdtsc64, erdtsc64; 
     64    u32 srdtsc_l, srdtsc_h; 
     65    u32 erdtsc_l, erdtsc_h; 
     66 
     67    rdtsc(srdtsc_l, srdtsc_h);  /* Get RDTSC */ 
     68    sleep(2);                   /* Sleep for 2 seconds */ 
     69    rdtsc(erdtsc_l, erdtsc_h);  /* Get RDTSC again */ 
     70 
     71    srdtsc64 = srdtsc_h; 
     72    srdtsc64 <<= 32; 
     73    srdtsc64 |= srdtsc_l; 
     74    erdtsc64 = erdtsc_h; 
     75    erdtsc64 <<= 32; 
     76    erdtsc64 |= erdtsc_l; 
     77 
     78 
     79    u32 diff = erdtsc64 - srdtsc64;     /* Cycle count for 2 seconds */ 
     80    diff /= 2;                  /* Divide by 2 to get cycles per sec */ 
     81    return diff; 
    5382} 
    5483 
    … …  
    5786    printf("CPU%d\n", processor_info->id); 
    5887    printf("Vendor ID : %s\n", processor_info->vendor); 
     88    if (processor_info->frequency > 1000000000) 
     89    { 
     90        printf("Frequency : ~%dGhz (or something like that)\n", 
     91               processor_info->frequency / 1000000000); 
     92    } 
     93    else if (processor_info->frequency > 1000000) 
     94    { 
     95        printf("Frequency : ~%dMhz (or something like that)\n", 
     96               processor_info->frequency / 1000000); 
     97    } 
     98    else if (processor_info->frequency > 1000) 
     99    { 
     100        printf("Frequency : ~%dKhz (or something like that)\n", 
     101               processor_info->frequency / 1000); 
     102    } 
     103    else 
     104    { 
     105        printf("Frequency : ~%dhz (you must be running Bochs)\n", 
     106               processor_info->frequency); 
     107    } 
    59108    printf("Features : 0x%x\n", processor_info->features); 
    60109} 

  • libcaca/trunk/kernel/drivers/processor.h

    r4158 r4159  
    9393    char vendor[13]; 
    9494    unsigned int features; 
     95    u32 frequency; 
    9596}; 
    9697 
    9798 
    9899int processor_get_info(struct processor_info *processor_info); 
     100u32 processor_get_frequency(struct processor_info *processor_info); 
    99101void processor_print_info(struct processor_info *processor_info); 

  • libcaca/trunk/kernel/drivers/timer.c

    r4158 r4159  
    1 /*  
     1/* 
    22 *  libcaca        
    33 *  libcaca       Colour ASCII-Art library 
    … …  
    2323void timer_phase(int hz) 
    2424{ 
    25     unsigned int divisor = 1193180 / hz;        /* Calculate our divisor */ 
    26     /*  
    27        0x43 is the Mode/Command register 
    28  
    29        From 
    30        http://wiki.osdev.org/Programmable_Interval_Timer#Read_Back_Status_Byte  
    31        : Bits Usage 6 and 7 Select channel : 0 0 = Channel 0 0 1 = Channel 1 
    32        1 0 = Channel 2 1 1 = Read-back command (8254 only) 4 and 5 Access mode  
    33        : 0 0 = Latch count value command 0 1 = Access mode: lobyte only 1 0 = 
    34        Access mode: hibyte only 1 1 = Access mode: lobyte/hibyte 1 to 3 
    35        Operating mode : 0 0 0 = Mode 0 (interrupt on terminal count) 0 0 1 = 
    36        Mode 1 (hardware re-triggerable one-shot) 0 1 0 = Mode 2 (rate 
    37        generator) 0 1 1 = Mode 3 (square wave generator) 1 0 0 = Mode 4 
    38        (software triggered strobe) 1 0 1 = Mode 5 (hardware triggered strobe) 
    39        1 1 0 = Mode 2 (rate generator, same as 010b) 1 1 1 = Mode 3 (square 
    40        wave generator, same as 011b) 0 BCD/Binary mode: 0 = 16-bit binary, 1 =  
    41        four-digit BCD 
    42  
     25    unsigned int divisor = 1193180 / hz;   /* Calculate our divisor */ 
     26    /* 
     27      0x43 is the Mode/Command register 
     28       
     29     From http://wiki.osdev.org/Programmable_Interval_Timer#Read_Back_Status_Byte :  
     30     Bits         Usage 
     31     6 and 7      Select channel : 
     32                  0 0 = Channel 0 
     33                  0 1 = Channel 1 
     34                  1 0 = Channel 2 
     35                  1 1 = Read-back command (8254 only) 
     36     4 and 5      Access mode : 
     37                  0 0 = Latch count value command 
     38                  0 1 = Access mode: lobyte only 
     39                  1 0 = Access mode: hibyte only 
     40                  1 1 = Access mode: lobyte/hibyte 
     41     1 to 3       Operating mode : 
     42                  0 0 0 = Mode 0 (interrupt on terminal count) 
     43                  0 0 1 = Mode 1 (hardware re-triggerable one-shot) 
     44                  0 1 0 = Mode 2 (rate generator) 
     45                  0 1 1 = Mode 3 (square wave generator) 
     46                  1 0 0 = Mode 4 (software triggered strobe) 
     47                  1 0 1 = Mode 5 (hardware triggered strobe) 
     48                  1 1 0 = Mode 2 (rate generator, same as 010b) 
     49                  1 1 1 = Mode 3 (square wave generator, same as 011b) 
     50     0            BCD/Binary mode: 0 = 16-bit binary, 1 = four-digit BCD 
     51      
    4352     */ 
    44     unsigned short command = 0 b00110110; 
     53    unsigned short command = 0b00110110; 
    4554    outb(0x43, command); 
    46     outb(0x40, divisor & 0xFF); /* Set low byte of divisor */ 
    47     outb(0x40, divisor >> 8);   /* Set high byte of divisor */ 
     55    outb(0x40, divisor & 0xFF);            /* Set low byte of divisor */ 
     56    outb(0x40, divisor >> 8);              /* Set high byte of divisor */ 
    4857} 

  • libcaca/trunk/kernel/kernel.c

    r4158 r4159  
    3737    printf("_start at 0x%x\n", _start); 
    3838    printf("kmain() at 0x%x\n", kmain); 
     39    printf("Types : char[%d] int[%d] long[%d] unsigned long long[%d]\n", sizeof(char), sizeof(int), sizeof(long), sizeof(unsigned long long)); 
     40     
     41    enable_interrupt(1);  // Enable Keyboard Interrupt (IRQ1) 
     42    enable_interrupt(0);  // Enable IRQ0 (timer) 
     43    enable_interrupt(13); 
     44    timer_phase(100);     // Fire IRQ0 each 1/100s 
     45     
    3946     
    4047    processor_get_info(&processor_info); 
    … …  
    4451    floppy_print_info(&floppy_info); 
    4552 
    46     enable_interrupt(1);  // Enable Keyboard Interrupt (IRQ1) 
    47     enable_interrupt(0);  // Enable IRQ0 (timer) 
    48     enable_interrupt(13); 
    49     timer_phase(100);     // Fire IRQ0 each 1/100s 
    50      
    51    
    52     printf("Waiting 1s\n"); 
    53     sleep(1); 
    54     printf("Waiting 2s\n"); 
    55     sleep(2); 
    56     printf("Waiting 3s\n"); 
    57     sleep(3); 
    58     printf("Ok\n"); 
    5953    //caca_get_display_driver_list(); 
    60      
     54    printf("Entering kernel infinite loop.\n"); 
    6155     
    6256    while (1) 

  • libcaca/trunk/kernel/kernel.h

    r4158 r4159  
    3131#define sti             __asm__("sti"::) 
    3232 
     33#define rdtsc(low,high) \ 
     34__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high)) 
    3335 
    3436 

  • libcaca/trunk/kernel/klibc.c

    r4158 r4159  
    1 /* 
     1/*  
    22 *  libcaca        
    33 *  libcaca       Colour ASCII-Art library 
    … …  
    3636 
    3737/* Our memory mapping */ 
    38 static uint32_t *freemem = (uint32_t*) 0x00200000; 
     38static uint32_t *freemem = (uint32_t *) 0x00200000; 
    3939int kX = 0; 
    4040int kY = 0; 
    … …  
    4242void scroll(void) 
    4343{ 
    44         unsigned char* video, *tmp; 
    45          
    46         for(video=(unsigned char*)0xB8000 ; video<(unsigned char*)0xB8FA0 ; video++){ 
    47         tmp = (unsigned char*) (video+1*160); 
    48          
    49         if(tmp<(unsigned char*)0xB8FA0) 
     44    unsigned char *video, *tmp; 
     45 
     46    for (video = (unsigned char *)0xB8000; video < (unsigned char *)0xB8FA0; 
     47         video++) 
     48    { 
     49        tmp = (unsigned char *)(video + 1 * 160); 
     50 
     51        if (tmp < (unsigned char *)0xB8FA0) 
    5052            *video = *tmp; 
    5153        else 
    5254            *video = 0; 
    53         } 
    54      
    55         kY-=1; 
    56         if(kY<0)  
    57                 kY=0;} 
     55    } 
     56 
     57    kY -= 1; 
     58    if (kY < 0) 
     59        kY = 0; 
     60} 
    5861 
    5962void putcar(unsigned char c) 
    6063{ 
    61         unsigned char* video; 
    62      
    63         if(c==10){       
    64                 kX=0; 
    65                 kY++; 
    66         } 
    67         else{ 
    68                 video = (unsigned char*) (0xB8000+2*kX+160*kY); 
    69                 *video = c; 
    70                 *(video+1) = 0x07; 
    71          
    72                 kX++; 
    73                 if(kX>79){ 
    74                         kX = 0; 
    75                         kY++; 
    76                 } 
    77         if(kY >= 24) { 
     64    unsigned char *video; 
     65 
     66    if (c == 10) 
     67    { 
     68        kX = 0; 
     69        kY++; 
     70    } 
     71    else 
     72    { 
     73        video = (unsigned char *)(0xB8000 + 2 * kX + 160 * kY); 
     74        *video = c; 
     75        *(video + 1) = 0x07; 
     76 
     77        kX++; 
     78        if (kX > 79) 
     79        { 
     80            kX = 0; 
     81            kY++; 
     82        } 
     83        if (kY >= 24) 
     84        { 
    7885            scroll(); 
    7986        } 
    … …  
    8491{ 
    8592    char const *ptr = str; 
    86     while(*ptr) { 
    87         putcar(*ptr++); 
     93    while (*ptr) 
     94    { 
     95        putcar(*ptr++); 
    8896    } 
    8997} 
    … …  
    94102    kX = 0; 
    95103    kY = 0; 
    96         for(y = 0; y < 25; y++) 
    97         for(x = 0; x < 80; x++) { 
    98                 putcar(' ');    
     104    for (y = 0; y < 25; y++) 
     105        for (x = 0; x < 80; x++) 
     106        { 
     107            putcar(' '); 
    99108        } 
    100109    kX = 0; 
    101     kY = 0;         
     110    kY = 0; 
    102111} 
    103112 
    … …  
    106115{ 
    107116    uint32_t *p = freemem; 
    108     if(!size) 
     117    if (!size) 
    109118        return NULL; 
    110119    size = (size + 0x7) / 4; 
    … …  
    123132    uint32_t oldsize; 
    124133    void *p; 
    125      
    126     if(!size) 
     134 
     135    if (!size) 
    127136        return NULL; 
    128      
    129     if(!ptr) 
     137 
     138    if (!ptr) 
    130139        oldsize = 0; 
    131140    else 
    132141    { 
    133         oldsize = ((uint32_t *)ptr)[-1]; 
    134         if(oldsize >= size) 
     142        oldsize = ((uint32_t *) ptr)[-1]; 
     143        if (oldsize >= size) 
    135144            return ptr; 
    136145    } 
    137      
     146 
    138147    p = malloc(size); 
    139148    memcpy(p, ptr, oldsize); 
    … …  
    169178int abs(int j) 
    170179{ 
    171     if(j < 0) 
     180    if (j < 0) 
    172181        return -j; 
    173182    return j; 
    … …  
    177186{ 
    178187    /* FIXME: reboot? */ 
    179     while(1); 
    180 } 
    181  
    182 int atexit(void (*function)(void)) 
     188    while (1); 
     189} 
     190 
     191int atexit(void (*function) (void)) 
    183192{ 
    184193    /* FIXME: register function */ 
    … …  
    190199{ 
    191200    uint8_t *ptr = s; 
    192      
    193     while(n--) 
     201 
     202    while (n--) 
    194203        *ptr++ = c; 
    195      
     204 
    196205    return s; 
    197206} 
    … …  
    201210    uint8_t *destptr = dest; 
    202211    uint8_t const *srcptr = src; 
    203      
    204     while(n--) 
     212 
     213    while (n--) 
    205214        *destptr++ = *srcptr++; 
    206      
     215 
    207216    return dest; 
    208217} 
    … …  
    218227{ 
    219228    int len = 0; 
    220      
    221     while(*s++) 
     229 
     230    while (*s++) 
    222231        len++; 
    223      
     232 
    224233    return len; 
    225234} 
    … …  
    227236int strcmp(const char *s1, const char *s2) 
    228237{ 
    229     while(*s1 && *s1 == *s2) 
     238    while (*s1 && *s1 == *s2) 
    230239    { 
    231240        s1++; 
    232241        s2++; 
    233242    } 
    234      
     243 
    235244    return (int)*s1 - (int)*s2; 
    236245} 
    … …  
    238247int strcasecmp(const char *s1, const char *s2) 
    239248{ 
    240     while(*s1 && *s2 && UPPER(*s1) == UPPER(*s2)) 
     249    while (*s1 && *s2 && UPPER(*s1) == UPPER(*s2)) 
    241250    { 
    242251        s1++; 
    243252        s2++; 
    244253    } 
    245      
     254 
    246255    return (int)UPPER(*s1) - (int)UPPER(*s2); 
    247256} 
    … …  
    250259{ 
    251260    uint8_t const *s1 = _s1, *s2 = _s2; 
    252      
    253     while(n--) 
    254     { 
    255         if(*s1 != *s2) 
     261 
     262    while (n--) 
     263    { 
     264        if (*s1 != *s2) 
    256265            return (int)*s1 - (int)*s2; 
    257266        s1++; 
    … …  
    265274    char *new; 
    266275    unsigned int len = strlen(s); 
    267      
     276 
    268277    new = malloc(len + 1); 
    269278    memcpy(new, s, len + 1); 
    270      
     279 
    271280    return new; 
    272281} 
    … …  
    275284{ 
    276285    do 
    277         if(*s == c) 
    278             return (char *)(intptr_t)s; 
    279     while(*s++); 
    280      
     286        if (*s == c) 
     287            return (char *)(intptr_t) s; 
     288    while (*s++); 
     289 
    281290    return NULL; 
    282291} 
    … …  
    296305} 
    297306 
    298 int feof(FILE *stream) 
    299 { 
    300     /* FIXME */ 
    301     return 0; 
    302 } 
    303  
    304 char *fgets(char *s, int size, FILE *stream) 
     307int feof(FILE * stream) 
     308{ 
     309    /* FIXME */ 
     310    return 0; 
     311} 
     312 
     313char *fgets(char *s, int size, FILE * stream) 
    305314{ 
    306315    /* FIXME */ 
    … …  
    308317} 
    309318 
    310 size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) 
    311 { 
    312     return 0; 
    313 } 
    314  
    315 int fclose(FILE *fp) 
     319size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE * stream) 
     320{ 
     321    return 0; 
     322} 
     323 
     324int fclose(FILE * fp) 
    316325{ 
    317326    /* FIXME */ 
    … …  
    325334    args_list args; 
    326335    args_start(args, fmt); 
    327      
     336 
    328337    char *s; 
    329338    int ptr = 0; 
    330339    int i = 0; 
    331      
    332     for (; fmt[i]; ++i) { 
    333         if ((fmt[i]!='%') && (fmt[i]!='\\')) { 
     340 
     341    for (; fmt[i]; ++i) 
     342    { 
     343        if ((fmt[i] != '%') && (fmt[i] != '\\')) 
     344        { 
    334345            str[ptr++] = fmt[i]; 
    335346            continue; 
    336         } else if (fmt[i] == '\\') { 
    337             switch (fmt[++i]) { 
    338                 case 'a': str[ptr++] = '\a'; break; 
    339                 case 'b': str[ptr++] = '\b'; break; 
    340                 case 't': str[ptr++] = '\t'; break; 
    341                 case 'n': str[ptr++] = '\n'; break; 
    342                 case 'r': str[ptr++] = '\r'; break; 
    343                 case '\\':str[ptr++] = '\\'; break; 
     347        } 
     348        else if (fmt[i] == '\\') 
     349        { 
     350            switch (fmt[++i]) 
     351            { 
     352            case 'a': 
     353                str[ptr++] = '\a'; 
     354                break; 
     355            case 'b': 
     356                str[ptr++] = '\b'; 
     357                break; 
     358            case 't': 
     359                str[ptr++] = '\t'; 
     360                break; 
     361            case 'n': 
     362                str[ptr++] = '\n'; 
     363                break; 
     364            case 'r': 
     365                str[ptr++] = '\r'; 
     366                break; 
     367            case '\\': 
     368                str[ptr++] = '\\'; 
     369                break; 
    344370            } 
    345371            continue; 
    346372        } 
    347          
    348         switch (fmt[++i]) { 
    349             case 's': 
    350                 s = (char *)args_next(args, char *); 
    351                 while (*s) 
    352                     str[ptr++] = *s++; 
    353                 break; 
    354             case 'c': 
    355                 str[ptr++] = (char)args_next(args, int); 
    356                 break; 
    357             case 'p': 
    358             case 'x': 
    359                 htoa((unsigned long)args_next(args, unsigned long), tmp); 
    360                 memcpy(&str[ptr], tmp, strlen(tmp)); 
    361                 ptr+=strlen(tmp); 
    362                 break; 
    363             case 'd': 
    364                 itoa((unsigned long)args_next(args, unsigned long), tmp); 
    365                 memcpy(&str[ptr], tmp, strlen(tmp)); 
    366                 ptr+=strlen(tmp); 
    367                 break; 
    368             case '%': 
    369                 str[ptr++] = '%'; 
    370                 break; 
    371             default: 
    372                 str[ptr++] = fmt[i]; 
    373                 break; 
    374         } 
    375     } 
    376      
     373 
     374        switch (fmt[++i]) 
     375        { 
     376        case 's': 
     377            s = (char *)args_next(args, char *); 
     378            while (*s) 
     379                str[ptr++] = *s++; 
     380            break; 
     381        case 'c': 
     382            str[ptr++] = (char)args_next(args, int); 
     383            break; 
     384        case 'p': 
     385        case 'x': 
     386            htoa((unsigned long)args_next(args, unsigned long), tmp); 
     387            memcpy(&str[ptr], tmp, strlen(tmp)); 
     388            ptr += strlen(tmp); 
     389            break; 
     390        case 'd': 
     391            itoa((unsigned long)args_next(args, unsigned long), tmp); 
     392            memcpy(&str[ptr], tmp, strlen(tmp)); 
     393            ptr += strlen(tmp); 
     394            break; 
     395        case '%': 
     396            str[ptr++] = '%'; 
     397            break; 
     398        default: 
     399            str[ptr++] = fmt[i]; 
     400            break; 
     401        } 
     402    } 
     403 
    377404    str[ptr] = '\0'; 
    378405    args_end(args); 
    379      
     406 
    380407    print(str); 
    381      
    382     return 0; 
    383 } 
    384  
    385 int fprintf(FILE *stream, const char *format, ...) 
    386 { 
    387     /* FIXME */ 
    388     return 0; 
    389 } 
    390  
    391 int fflush(FILE *stream) 
     408 
     409    return 0; 
     410} 
     411 
     412int fprintf(FILE * stream, const char *format, ...) 
     413{ 
     414    /* FIXME */ 
     415    return 0; 
     416} 
     417 
     418int fflush(FILE * stream) 
    392419{ 
    393420    /* FIXME */ 
    … …  
    400427    args_list args; 
    401428    args_start(args, fmt); 
    402      
     429 
    403430    char *s; 
    404431    int ptr = 0; 
    405432    int i = 0; 
    406      
    407     for (; fmt[i]; ++i) { 
    408         if ((fmt[i]!='%') && (fmt[i]!='\\')) { 
     433 
     434    for (; fmt[i]; ++i) 
     435    { 
     436        if ((fmt[i] != '%') && (fmt[i] != '\\')) 
     437        { 
    409438            str[ptr++] = fmt[i]; 
    410439            continue; 
    411         } else if (fmt[i] == '\\') { 
    412             switch (fmt[++i]) { 
    413                 case 'a': str[ptr++] = '\a'; break; 
    414                 case 'b': str[ptr++] = '\b'; break; 
    415                 case 't': str[ptr++] = '\t'; break; 
    416                 case 'n': str[ptr++] = '\n'; break; 
    417                 case 'r': str[ptr++] = '\r'; break; 
    418                 case '\\':str[ptr++] = '\\'; break; 
     440        } 
     441        else if (fmt[i] == '\\') 
     442        { 
     443            switch (fmt[++i]) 
     444            { 
     445            case 'a': 
     446                str[ptr++] = '\a'; 
     447                break; 
     448            case 'b': 
     449                str[ptr++] = '\b'; 
     450                break; 
     451            case 't': 
     452                str[ptr++] = '\t'; 
     453                break; 
     454            case 'n': 
     455                str[ptr++] = '\n'; 
     456                break; 
     457            case 'r': 
     458                str[ptr++] = '\r'; 
     459                break; 
     460            case '\\': 
     461                str[ptr++] = '\\'; 
     462                break; 
    419463            } 
    420464            continue; 
    421465        } 
    422      
    423         switch (fmt[++i]) { 
    424             case 's': 
    425                 s = (char *)args_next(args, char *); 
    426                 while (*s) 
    427                     str[ptr++] = *s++; 
    428                 break; 
    429             case 'c': 
    430                 str[ptr++] = (char)args_next(args, int); 
    431                 break; 
    432             case 'p': 
    433             case 'x': 
    434                 htoa((unsigned long)args_next(args, unsigned long), tmp); 
    435                 memcpy(&str[ptr], tmp, strlen(tmp)); 
    436                 ptr+=strlen(tmp); 
    437                 break; 
    438             case 'd': 
    439                 itoa((unsigned long)args_next(args, unsigned long), tmp); 
    440                 memcpy(&str[ptr], tmp, strlen(tmp)); 
    441                 ptr+=strlen(tmp); 
    442                 break; 
    443             case '%': 
    444                 str[ptr++] = '%'; 
    445                 break; 
    446             default: 
    447                 str[ptr++] = fmt[i]; 
    448                 break; 
     466 
     467        switch (fmt[++i]) 
     468        { 
     469        case 's': 
     470            s = (char *)args_next(args, char *); 
     471            while (*s) 
     472                str[ptr++] = *s++; 
     473            break; 
     474        case 'c': 
     475            str[ptr++] = (char)args_next(args, int); 
     476            break; 
     477        case 'p': 
     478        case 'x': 
     479            htoa((unsigned long)args_next(args, unsigned long), tmp); 
     480            memcpy(&str[ptr], tmp, strlen(tmp)); 
     481            ptr += strlen(tmp); 
     482            break; 
     483        case 'd': 
     484            itoa((unsigned long)args_next(args, unsigned long), tmp); 
     485            memcpy(&str[ptr], tmp, strlen(tmp)); 
     486            ptr += strlen(tmp); 
     487            break; 
     488        case '%': 
     489            str[ptr++] = '%'; 
     490            break; 
     491        default: 
     492            str[ptr++] = fmt[i]; 
     493            break; 
    449494        } 
    450495    } 
    … …  
    465510void usleep(unsigned long usec) 
    466511{ 
    467         u32 start = ticks; 
    468     signed int diff  = 0; 
    469      
    470     while(1) { 
     512    u32 start = ticks; 
     513    signed int diff = 0; 
     514 
     515    while (1) 
     516    { 
    471517        diff = (signed int)(ticks - start); 
    472         if(diff >= (signed int)(usec/20)) break; 
    473     } 
    474 } 
    475  
    476 void sleep(unsigned long sec)    
    477 { 
    478         usleep(sec*1000);        
    479 } 
    480  
    481 /* time.h functions */ 
    482   u64 rdtsc() { 
    483     u64 x; 
    484     __asm__ volatile ("rdtsc" : "=A" (x)); 
    485     return x; 
    486 } 
     518        if (diff >= (signed int)(usec / 20)) 
     519            break; 
     520    } 
     521} 
     522 
     523void sleep(unsigned long sec) 
     524{ 
     525    usleep(sec * 1000); 
     526} 
     527 
    487528 
    488529int gettimeofday(struct timeval *tv, struct timezone *tz) 
    … …  
    490531    static int usec = 0; 
    491532    static int sec = 0; 
    492      
     533 
    493534    /* FIXME */ 
    494535    usec += 10000; 
    495     if(usec > 1000000) 
     536    if (usec > 1000000) 
    496537    { 
    497538        sec++; 
    498539        usec -= 1000000; 
    499540    } 
    500      
     541 
    501542    tv->tv_sec = sec; 
    502543    tv->tv_usec = usec; 
    503      
     544 
    504545    return 0; 
    505546} 
    … …  
    510551    double ret = 0.0; 
    511552#ifdef HAVE_FSIN_FCOS 
    512     asm volatile("fcos" : "=t" (ret) : "0" (x)); 
     553    asm volatile ("fcos":"=t" (ret):"0"(x)); 
    513554#else 
    514555    double x2; 
    … …  
    516557    double fact = 1.0; 
    517558    int i; 
    518      
     559 
    519560    x = x - ((double)(int)(x / (2 * M_PI))) * (2 * M_PI); 
    520561    x2 = x * x; 
    521      
     562 
    522563    /* cos(x) = 1/0! - x^2/2! + x^4/4! - x^6/6! ... */ 
    523     for(i = 0; i < 10; i++) 
     564    for (i = 0; i < 10; i++) 
    524565    { 
    525566        ret += num / fact; 
    526         num *= - x2; 
     567        num *= -x2; 
    527568        fact *= (2 * i + 1) * (2 * i + 2); 
    528569    } 
    … …  
    535576    double ret = 0.0; 
    536577#ifdef HAVE_FSIN_FCOS 
    537     asm volatile("fsin" : "=t" (ret) : "0" (x)); 
     578    asm volatile ("fsin":"=t" (ret):"0"(x)); 
    538579#else 
    539580    double x2; 
    … …  
    541582    double fact = 1.0; 
    542583    int i; 
    543      
     584 
    544585    x = x - ((double)(int)(x / (2 * M_PI))) * (2 * M_PI); 
    545586    x2 = x * x; 
    546587    num = x; 
    547      
     588 
    548589    /* sin(x) = x/1! - x^3/3! + x^5/5! - x^7/7! ... */ 
    549     for(i = 0; i < 10; i++) 
     590    for (i = 0; i < 10; i++) 
    550591    { 
    551592        ret += num / fact; 
    552         num *= - x2; 
     593        num *= -x2; 
    553594        fact *= (2 * i + 2) * (2 * i + 3); 
    554595    } 
    … …  
    561602    double ret = x; 
    562603    int i; 
    563      
     604 
    564605    /* This is Newton's method */ 
    565     for(i = 0; i < 10; i++) 
     606    for (i = 0; i < 10; i++) 
    566607        ret = (ret * ret + x) / (ret * 2.0); 
    567      
     608 
    568609    return ret; 
    569610} 
    570611 
    571612 
    572 /* reverse:  reverse string s in place */ 
     613/* reverse: reverse string s in place */ 
    573614void reverse(char s[]) 
    574615{ 
    575616    int i, j; 
    576617    char c; 
    577      
    578     for (i = 0, j = strlen(s)-1; i<j; i++, j--) { 
     618 
     619    for (i = 0, j = strlen(s) - 1; i < j; i++, j--) 
     620    { 
    579621        c = s[i]; 
    580622        s[i] = s[j]; 
    … …  
    588630{ 
    589631    int i, sign; 
    590      
    591     if ((sign = n) < 0)  /* record sign */ 
    592         n = -n;          /* make n positive */ 
     632 
     633    if ((sign = n) < 0)         /* record sign */ 
     634        n = -n;                 /* make n positive */ 
    593635    i = 0; 
    594     do {       /* generate digits in reverse order */ 
    595         s[i++] = n % 10 + '0';   /* get next digit */ 
    596     } while ((n /= 10) > 0);     /* delete it */ 
     636    do 
     637    {                           /* generate digits in reverse order */ 
     638        s[i++] = n % 10 + '0';  /* get next digit */ 
     639    } 
     640    while ((n /= 10) > 0);      /* delete it */ 
    597641    if (sign < 0) 
    598642        s[i++] = '-'; 
    599643    s[i] = '\0'; 
    600644    reverse(s); 
    601 }  
    602  
    603 void htoa(unsigned int value, char s[]) { 
     645} 
     646 
     647void htoa(unsigned int value, char s[]) 
     648{ 
    604649    int i = 8; 
    605650    int ptr = 0; 
    606     while (i-- > 0) { 
    607         s[ptr++] = "0123456789abcdef"[(value>>(i*4))&0xf]; 
     651    while (i-- > 0) 
     652    { 
     653        s[ptr++] = "0123456789abcdef"[(value >> (i * 4)) & 0xf]; 
    608654    } 
    609655    s[ptr] = 0; 

  • libcaca/trunk/kernel/klibc.h

    r4158 r4159  
    4242typedef unsigned short u16; 
    4343typedef unsigned int u32; 
    44 typedef unsigned long int u64; 
     44typedef unsigned long long u64; 
    4545 
    4646#ifndef size_t 
    … …  
    124124 
    125125/* time.h functions */ 
    126 u64 rdtsc(void); 
    127126int gettimeofday(struct timeval *tv, struct timezone *tz); 
    128127int time(void *); 
Note: See TracChangeset for help on using the changeset viewer.