Changes in / [24f27bb:cb0ea39] in mainline


Ignore:
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/include/cpu.h

    r24f27bb rcb0ea39  
    3636#define KERN_amd64_CPU_H_
    3737
    38 #define RFLAGS_CF       (1 << 0)
    39 #define RFLAGS_PF       (1 << 2)
    40 #define RFLAGS_AF       (1 << 4)
    41 #define RFLAGS_ZF       (1 << 6)
    42 #define RFLAGS_SF       (1 << 7)
    43 #define RFLAGS_TF       (1 << 8)
    44 #define RFLAGS_IF       (1 << 9)
    45 #define RFLAGS_DF       (1 << 10)
    46 #define RFLAGS_OF       (1 << 11)
    47 #define RFLAGS_RF       (1 << 16)
     38#define RFLAGS_IF  (1 << 9)
     39#define RFLAGS_DF  (1 << 10)
     40#define RFLAGS_RF  (1 << 16)
    4841
    4942#define EFER_MSR_NUM    0xc0000080

  • kernel/arch/amd64/src/userspace.c

    r24f27bb rcb0ea39  
    3434
    3535#include <userspace.h>
    36 #include <arch/cpu.h>
    3736#include <arch/pm.h>
    3837#include <arch/types.h>
    … …  
    5150        ipl_t ipl = interrupts_disable();
    5251       
    53         ipl &= ~(RFLAGS_CF | RFLAGS_PF | RFLAGS_AF | RFLAGS_ZF | RFLAGS_SF |
    54             RFLAGS_DF | RFLAGS_OF);
     52        /* Clear CF, PF, AF, ZF, SF, DF, OF */
     53        ipl &= ~(0xcd4);
    5554       
    5655        asm volatile (
    57                 "pushq %[udata_des]\n"
    58                 "pushq %[stack_size]\n"
    59                 "pushq %[ipl]\n"
    60                 "pushq %[utext_des]\n"
    61                 "pushq %[entry]\n"
    62                 "movq %[uarg], %%rax\n"
     56                        "pushq %[udata_des]\n"
     57                        "pushq %[stack_size]\n"
     58                        "pushq %[ipl]\n"
     59                        "pushq %[utext_des]\n"
     60                        "pushq %[entry]\n"
     61                        "movq %[uarg], %%rax\n"
    6362                       
    64                 /* %rdi is defined to hold pcb_ptr - set it to 0 */
    65                 "xorq %%rdi, %%rdi\n"
    66                 "iretq\n"
    67                 :: [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
    68                    [stack_size] "r" (kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
    69                    [ipl] "r" (ipl),
    70                    [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
    71                    [entry] "r" (kernel_uarg->uspace_entry),
    72                    [uarg] "r" (kernel_uarg->uspace_uarg)
    73                 : "rax"
    74         );
     63                        /* %rdi is defined to hold pcb_ptr - set it to 0 */
     64                        "xorq %%rdi, %%rdi\n"
     65                        "iretq\n"
     66                        :: [udata_des] "i" (gdtselector(UDATA_DES) | PL_USER),
     67                           [stack_size] "r" (kernel_uarg->uspace_stack + THREAD_STACK_SIZE),
     68                           [ipl] "r" (ipl),
     69                           [utext_des] "i" (gdtselector(UTEXT_DES) | PL_USER),
     70                           [entry] "r" (kernel_uarg->uspace_entry),
     71                           [uarg] "r" (kernel_uarg->uspace_uarg)
     72                        : "rax"
     73                );
    7574       
    7675        /* Unreachable */
    77         while (1)
    78                 ;
     76        while (1);
    7977}
    8078

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

    r24f27bb rcb0ea39  
    135135void userspace(uspace_arg_t *kernel_uarg)
    136136{
    137         (void) interrupts_disable();
    138137        switch_to_userspace((uintptr_t) kernel_uarg->uspace_entry,
    139138            ((uintptr_t) kernel_uarg->uspace_stack) + STACK_SIZE

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

    r24f27bb rcb0ea39  
    4545#include <arch.h>
    4646
    47 /** The events array. */
     47/**
     48 * The events array.
     49 * Arranging the events in this two-dimensional array should decrease the
     50 * likelyhood of cacheline ping-pong.
     51 */
    4852static event_t events[EVENT_END];
    4953

  • kernel/generic/src/main/uinit.c

    r24f27bb rcb0ea39  
    8181        free((uspace_arg_t *) arg);
    8282       
     83        /*
     84         * Disable interrupts so that the execution of userspace() is not
     85         * disturbed by any interrupts as some of the userspace()
     86         * implementations will switch to the userspace stack before switching
     87         * the mode.
     88         */
     89        (void) interrupts_disable();
    8390        userspace(&uarg);
    8491}

  • kernel/generic/src/printf/printf_core.c

    r24f27bb rcb0ea39  
    491491                counter += retval;
    492492       
    493         /* Print trailing spaces */
     493        /* Print tailing spaces */
    494494       
    495495        while (width-- > 0) {

  • kernel/generic/src/printf/vsnprintf.c

    r24f27bb rcb0ea39  
    100100        }
    101101       
    102         /* Buffer is big enough to print the whole string */
     102        /* Buffer is big enought to print the whole string */
    103103        memcpy((void *)(data->dst + data->len), (void *) str, size);
    104104        data->len += size;

  • kernel/generic/src/proc/task.c

    r24f27bb rcb0ea39  
    7575static task_id_t task_counter = 0;
    7676
    77 /* Forward declarations. */
    78 static void task_kill_internal(task_t *);
    79 
    8077/** Initialize kernel tasks support. */
    8178void task_init(void)
    … …  
    8683
    8784/*
    88  * The idea behind this walker is to kill and count all tasks different from
     85 * The idea behind this walker is to remember a single task different from
    8986 * TASK.
    9087 */
    … …  
    9289{
    9390        task_t *t = avltree_get_instance(node, task_t, tasks_tree_node);
    94         unsigned *cnt = (unsigned *) arg;
    95 
    96         if (t != TASK) {
    97                 (*cnt)++;
    98 #ifdef CONFIG_DEBUG
    99                 printf("[%"PRIu64"] ", t->taskid);
    100 #endif
    101                 task_kill_internal(t);
     91        task_t **tp = (task_t **) arg;
     92
     93        if (t != TASK) {
     94                *tp = t;
     95                return false;   /* stop walking */
    10296        }
    10397
    … …  
    108102void task_done(void)
    109103{
    110         unsigned tasks_left;
    111 
     104        task_t *t;
    112105        do { /* Repeat until there are any tasks except TASK */
     106               
    113107                /* Messing with task structures, avoid deadlock */
    114 #ifdef CONFIG_DEBUG
    115                 printf("Killing tasks... ");
    116 #endif
    117108                ipl_t ipl = interrupts_disable();
    118109                spinlock_lock(&tasks_lock);
    119                 tasks_left = 0;
    120                 avltree_walk(&tasks_tree, task_done_walker, &tasks_left);
    121                 spinlock_unlock(&tasks_lock);
    122                 interrupts_restore(ipl);
    123                 thread_sleep(1);
     110               
     111                t = NULL;
     112                avltree_walk(&tasks_tree, task_done_walker, &t);
     113               
     114                if (t != NULL) {
     115                        task_id_t id = t->taskid;
     116                       
     117                        spinlock_unlock(&tasks_lock);
     118                        interrupts_restore(ipl);
     119                       
    124120#ifdef CONFIG_DEBUG
    125                 printf("\n");
    126 #endif
    127         } while (tasks_left);
     121                        printf("Killing task %" PRIu64 "\n", id);
     122#endif                 
     123                        task_kill(id);
     124                        thread_usleep(10000);
     125                } else {
     126                        spinlock_unlock(&tasks_lock);
     127                        interrupts_restore(ipl);
     128                }
     129               
     130        } while (t != NULL);
    128131}
    129132
    … …  
    347350}
    348351
    349 static void task_kill_internal(task_t *ta)
    350 {
    351         link_t *cur;
    352 
    353         /*
    354          * Interrupt all threads.
    355          */
    356         spinlock_lock(&ta->lock);
    357         for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
    358                 thread_t *thr;
    359                 bool sleeping = false;
    360                
    361                 thr = list_get_instance(cur, thread_t, th_link);
    362                
    363                 spinlock_lock(&thr->lock);
    364                 thr->interrupted = true;
    365                 if (thr->state == Sleeping)
    366                         sleeping = true;
    367                 spinlock_unlock(&thr->lock);
    368                
    369                 if (sleeping)
    370                         waitq_interrupt_sleep(thr);
    371         }
    372         spinlock_unlock(&ta->lock);
    373 }
    374 
    375352/** Kill task.
    376353 *
    … …  
    386363        ipl_t ipl;
    387364        task_t *ta;
     365        link_t *cur;
    388366
    389367        if (id == 1)
    … …  
    397375                return ENOENT;
    398376        }
    399         task_kill_internal(ta);
    400377        spinlock_unlock(&tasks_lock);
     378       
     379        /*
     380         * Interrupt all threads.
     381         */
     382        spinlock_lock(&ta->lock);
     383        for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
     384                thread_t *thr;
     385                bool sleeping = false;
     386               
     387                thr = list_get_instance(cur, thread_t, th_link);
     388               
     389                spinlock_lock(&thr->lock);
     390                thr->interrupted = true;
     391                if (thr->state == Sleeping)
     392                        sleeping = true;
     393                spinlock_unlock(&thr->lock);
     394               
     395                if (sleeping)
     396                        waitq_interrupt_sleep(thr);
     397        }
     398        spinlock_unlock(&ta->lock);
    401399        interrupts_restore(ipl);
     400       
    402401        return 0;
    403402}

  • tools/config.py

    r24f27bb rcb0ea39  
    225225        "Create output configuration"
    226226       
    227         revision = commands.getoutput('bzr version-info --custom --template="{revision_id}" 2> /dev/null')
     227        revision = commands.getoutput('svnversion . 2> /dev/null')
    228228        timestamp = commands.getoutput('date "+%Y-%m-%d %H:%M:%S"')
    229229       

  • uspace/lib/libc/generic/io/printf_core.c

    r24f27bb rcb0ea39  
    490490                counter += retval;
    491491       
    492         /* Print trailing spaces */
     492        /* Print tailing spaces */
    493493       
    494494        while (width-- > 0) {

  • uspace/lib/libc/generic/io/vsnprintf.c

    r24f27bb rcb0ea39  
    100100        }
    101101       
    102         /* Buffer is big enough to print the whole string */
     102        /* Buffer is big enought to print the whole string */
    103103        memcpy((void *)(data->dst + data->len), (void *) str, size);
    104104        data->len += size;

  • uspace/lib/libc/generic/malloc.c

    r24f27bb rcb0ea39  
    392392                if (orig_size - real_size >= STRUCT_OVERHEAD) {
    393393                        /* Split the original block to a full block
    394                            and a trailing free block */
     394                           and a tailing free block */
    395395                        block_init((void *) head, real_size, false);
    396396                        block_init((void *) head + real_size,

  • uspace/srv/bd/ata_bd/ata_bd.c

    r24f27bb rcb0ea39  
    3636 *
    3737 * This driver currently works only with CHS addressing and uses PIO.
    38  * Currently based on the (now obsolete) ATA-1, ATA-2 standards.
     38 * Currently based on the (now obsolete) ANSI X3.221-1994 (ATA-1) standard.
     39 * At this point only reading is possible, not writing.
    3940 *
    4041 * The driver services a single controller which can have up to two disks
    … …  
    6061#define NAME "ata_bd"
    6162
    62 /** Physical block size. Should be always 512. */
    6363static const size_t block_size = 512;
    64 
    65 /** Size of the communication area. */
    6664static size_t comm_size;
    6765
    68 /** I/O base address of the command registers. */
    6966static uintptr_t cmd_physical = 0x1f0;
    70 /** I/O base address of the control registers. */
    7167static uintptr_t ctl_physical = 0x170;
    72 
    7368static ata_cmd_t *cmd;
    7469static ata_ctl_t *ctl;
    … …  
    8681    const void *buf);
    8782static int drive_identify(int drive_id, disk_t *d);
    88 static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
    89     unsigned timeout);
    9083
    9184int main(int argc, char **argv)
    9285{
     86        uint8_t status;
    9387        char name[16];
    9488        int i, rc;
    … …  
    10296                return -1;
    10397
    104         for (i = 0; i < MAX_DISKS; i++) {
    105                 printf("Identify drive %d... ", i);
    106                 fflush(stdout);
    107 
    108                 rc = drive_identify(i, &disk[i]);
    109 
    110                 if (rc == EOK) {
    111                         printf("%u cylinders, %u heads, %u sectors\n",
    112                             disk[i].cylinders, disk[i].heads, disk[i].sectors);
    113                 } else {
    114                         printf("Not found.\n");
    115                 }
    116         }
     98        /* Put drives to reset, disable interrupts. */
     99        printf("Reset drives... ");
     100        fflush(stdout);
     101
     102        pio_write_8(&ctl->device_control, DCR_SRST);
     103        /* FIXME: Find out how to do this properly. */
     104        async_usleep(100);
     105        pio_write_8(&ctl->device_control, 0);
     106
     107        do {
     108                status = pio_read_8(&cmd->status);
     109        } while ((status & SR_BSY) != 0);
     110        printf("Done\n");
     111
     112        (void) drive_identify(0, &disk[0]);
     113        (void) drive_identify(1, &disk[1]);
    117114
    118115        n_disks = 0;
    … …  
    147144}
    148145
    149 
    150 /** Register driver and enable device I/O. */
     146static int drive_identify(int disk_id, disk_t *d)
     147{
     148        uint16_t data;
     149        uint8_t status;
     150        size_t i;
     151
     152        printf("Identify drive %d... ", disk_id);
     153        fflush(stdout);
     154
     155        pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
     156        async_usleep(100);
     157        pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
     158
     159        status = pio_read_8(&cmd->status);
     160
     161        d->present = false;
     162
     163        /*
     164         * Detect if drive is present. This is Qemu only! Need to
     165         * do the right thing to work with real drives.
     166         */
     167        if ((status & SR_DRDY) == 0) {
     168                printf("None attached.\n");
     169                return ENOENT;
     170        }
     171
     172        for (i = 0; i < block_size / 2; i++) {
     173                do {
     174                        status = pio_read_8(&cmd->status);
     175                } while ((status & SR_DRDY) == 0);
     176
     177                data = pio_read_16(&cmd->data_port);
     178
     179                switch (i) {
     180                case 1: d->cylinders = data; break;
     181                case 3: d->heads = data; break;
     182                case 6: d->sectors = data; break;
     183                }
     184        }
     185
     186        d->blocks = d->cylinders * d->heads * d->sectors;
     187
     188        printf("Geometry: %u cylinders, %u heads, %u sectors\n",
     189                d->cylinders, d->heads, d->sectors);
     190
     191        d->present = true;
     192        fibril_mutex_initialize(&d->lock);
     193
     194        return EOK;
     195}
     196
    151197static int ata_bd_init(void)
    152198{
    … …  
    180226}
    181227
    182 /** Block device connection handler */
    183228static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
    184229{
    … …  
    251296}
    252297
    253 /** Transfer a logical block from/to the device.
    254  *
    255  * @param disk_id       Device index (0 or 1)
    256  * @param method        @c BD_READ_BLOCK or @c BD_WRITE_BLOCK
    257  * @param blk_idx       Index of the first block.
    258  * @param size          Size of the logical block.
    259  * @param buf           Data buffer.
    260  *
    261  * @return EOK on success, EIO on error.
    262  */
    263298static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
    264299    void *buf)
    … …  
    292327}
    293328
    294 /** Issue IDENTIFY command.
    295  *
    296  * This is used to detect whether an ATA device is present and if so,
    297  * to determine its parameters. The parameters are written to @a d.
    298  *
    299  * @param disk_id       Device ID, 0 or 1.
    300  * @param d             Device structure to store parameters in.
    301  */
    302 static int drive_identify(int disk_id, disk_t *d)
    303 {
    304         uint16_t data;
    305         uint8_t status;
    306         uint8_t drv_head;
    307         size_t i;
    308 
    309         drv_head = ((disk_id != 0) ? DHR_DRV : 0);
    310         d->present = false;
    311 
    312         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    313                 return EIO;
    314 
    315         pio_write_8(&cmd->drive_head, drv_head);
    316 
    317         /*
    318          * This is where we would most likely expect a non-existing device to
    319          * show up by not setting SR_DRDY.
    320          */
    321         if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    322                 return EIO;
    323 
    324         pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
    325 
    326         if (wait_status(0, ~SR_BSY, &status, TIMEOUT_PROBE) != EOK)
    327                 return EIO;
    328 
    329         /* Read data from the disk buffer. */
    330 
    331         if ((status & SR_DRQ) != 0) {
    332 //              for (i = 0; i < block_size / 2; i++) {
    333 //                      data = pio_read_16(&cmd->data_port);
    334 //                      ((uint16_t *) buf)[i] = data;
    335 //              }
    336 
    337                 for (i = 0; i < block_size / 2; i++) {
    338                         data = pio_read_16(&cmd->data_port);
    339 
    340                         switch (i) {
    341                         case 1: d->cylinders = data; break;
    342                         case 3: d->heads = data; break;
    343                         case 6: d->sectors = data; break;
    344                         }
    345                 }
    346         }
    347 
    348         if ((status & SR_ERR) != 0)
    349                 return EIO;
    350 
    351         d->blocks = d->cylinders * d->heads * d->sectors;
    352 
    353         d->present = true;
    354         fibril_mutex_initialize(&d->lock);
    355 
    356         return EOK;
    357 }
    358 
    359 /** Read a physical from the device.
    360  *
    361  * @param disk_id       Device index (0 or 1)
    362  * @param blk_idx       Index of the first block.
    363  * @param blk_cnt       Number of blocks to transfer.
    364  * @param buf           Buffer for holding the data.
    365  *
    366  * @return EOK on success, EIO on error.
    367  */
     329
    368330static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
    369331    void *buf)
    … …  
    399361        /* Program a Read Sectors operation. */
    400362
    401         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    402                 fibril_mutex_unlock(&d->lock);
    403                 return EIO;
    404         }
    405 
    406363        pio_write_8(&cmd->drive_head, drv_head);
    407 
    408         if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    409                 fibril_mutex_unlock(&d->lock);
    410                 return EIO;
    411         }
    412 
    413364        pio_write_8(&cmd->sector_count, 1);
    414365        pio_write_8(&cmd->sector_number, s);
    415366        pio_write_8(&cmd->cylinder_low, c & 0xff);
    416367        pio_write_8(&cmd->cylinder_high, c >> 16);
    417 
    418368        pio_write_8(&cmd->command, CMD_READ_SECTORS);
    419369
    420         if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    421                 fibril_mutex_unlock(&d->lock);
    422                 return EIO;
    423         }
    424 
    425         if ((status & SR_DRQ) != 0) {
    426                 /* Read data from the device buffer. */
    427 
    428                 for (i = 0; i < block_size / 2; i++) {
    429                         data = pio_read_16(&cmd->data_port);
    430                         ((uint16_t *) buf)[i] = data;
    431                 }
    432         }
    433 
    434         if ((status & SR_ERR) != 0)
    435                 return EIO;
     370        /* Read data from the disk buffer. */
     371
     372        for (i = 0; i < block_size / 2; i++) {
     373                do {
     374                        status = pio_read_8(&cmd->status);
     375                } while ((status & SR_DRDY) == 0);
     376
     377                data = pio_read_16(&cmd->data_port);
     378                ((uint16_t *) buf)[i] = data;
     379        }
    436380
    437381        fibril_mutex_unlock(&d->lock);
    … …  
    439383}
    440384
    441 /** Write a physical block to the device.
    442  *
    443  * @param disk_id       Device index (0 or 1)
    444  * @param blk_idx       Index of the first block.
    445  * @param blk_cnt       Number of blocks to transfer.
    446  * @param buf           Buffer holding the data to write.
    447  *
    448  * @return EOK on success, EIO on error.
    449  */
    450385static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
    451386    const void *buf)
    … …  
    478413        fibril_mutex_lock(&d->lock);
    479414
    480         /* Program a Write Sectors operation. */
    481 
    482         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
    483                 fibril_mutex_unlock(&d->lock);
    484                 return EIO;
    485         }
     415        /* Program a Read Sectors operation. */
    486416
    487417        pio_write_8(&cmd->drive_head, drv_head);
    488 
    489         if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
    490                 fibril_mutex_unlock(&d->lock);
    491                 return EIO;
    492         }
    493 
    494418        pio_write_8(&cmd->sector_count, 1);
    495419        pio_write_8(&cmd->sector_number, s);
    496420        pio_write_8(&cmd->cylinder_low, c & 0xff);
    497421        pio_write_8(&cmd->cylinder_high, c >> 16);
    498 
    499422        pio_write_8(&cmd->command, CMD_WRITE_SECTORS);
    500423
    501         if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
    502                 fibril_mutex_unlock(&d->lock);
    503                 return EIO;
    504         }
    505 
    506         if ((status & SR_DRQ) != 0) {
    507                 /* Write data to the device buffer. */
    508 
    509                 for (i = 0; i < block_size / 2; i++) {
    510                         pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    511                 }
     424        /* Write data to the disk buffer. */
     425
     426        for (i = 0; i < block_size / 2; i++) {
     427                do {
     428                        status = pio_read_8(&cmd->status);
     429                } while ((status & SR_DRDY) == 0);
     430
     431                pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
    512432        }
    513433
    514434        fibril_mutex_unlock(&d->lock);
    515 
    516         if (status & SR_ERR)
    517                 return EIO;
    518 
    519435        return EOK;
    520436}
    521437
    522 /** Wait until some status bits are set and some are reset.
    523  *
    524  * Example: wait_status(SR_DRDY, ~SR_BSY) waits for SR_DRDY to become
    525  * set and SR_BSY to become reset.
    526  *
    527  * @param set           Combination if bits which must be all set.
    528  * @param n_reset       Negated combination of bits which must be all reset.
    529  * @param pstatus       Pointer where to store last read status or NULL.
    530  * @param timeout       Timeout in 10ms units.
    531  *
    532  * @return              EOK on success, EIO on timeout.
    533  */
    534 static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
    535     unsigned timeout)
    536 {
    537         uint8_t status;
    538         int cnt;
    539 
    540         status = pio_read_8(&cmd->status);
    541 
    542         /*
    543          * This is crude, yet simple. First try with 1us delays
    544          * (most likely the device will respond very fast). If not,
    545          * start trying every 10 ms.
    546          */
    547 
    548         cnt = 100;
    549         while ((status & ~n_reset) != 0 || (status & set) != set) {
    550                 async_usleep(1);
    551                 --cnt;
    552                 if (cnt <= 0) break;
    553 
    554                 status = pio_read_8(&cmd->status);
    555         }
    556 
    557         cnt = timeout;
    558         while ((status & ~n_reset) != 0 || (status & set) != set) {
    559                 async_usleep(10000);
    560                 --cnt;
    561                 if (cnt <= 0) break;
    562 
    563                 status = pio_read_8(&cmd->status);
    564         }
    565 
    566         if (pstatus)
    567                 *pstatus = status;
    568 
    569         if (cnt == 0)
    570                 return EIO;
    571 
    572         return EOK;
    573 }
    574438
    575439/**

  • uspace/srv/bd/ata_bd/ata_bd.h

    r24f27bb rcb0ea39  
    135135};
    136136
    137 /** Timeout definitions. Unit is 10 ms. */
    138 enum ata_timeout {
    139         TIMEOUT_PROBE   =  100, /*  1 s */
    140         TIMEOUT_BSY     =  100, /*  1 s */
    141         TIMEOUT_DRDY    = 1000  /* 10 s */
    142 };
    143 
    144137typedef struct {
    145138        bool present;
Note: See TracChangeset for help on using the changeset viewer.