Changeset 4159 for libcaca/trunk


Ignore:
Timestamp:
Dec 20, 2009, 4:41:41 PM (10 years ago)
Author:
Jean-Yves Lamoureux
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.