Changes in / [ab3a851:41a7f62] in mainline


Ignore:
Files:
3 added
7 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rab3a851 r41a7f62  
    109109       
    110110RD_DRVS = \
    111         root \
    112         rootvirt
     111        root
    113112
    114113RD_DRV_CFG =

  • boot/arch/amd64/Makefile.inc

    rab3a851 r41a7f62  
    3737
    3838RD_DRVS += \
    39         rootpc \
     39        rootia32 \
    4040        pciintel \
    4141        isa \

  • uspace/Makefile

    rab3a851 r41a7f62  
    8585        srv/net/tl/tcp \
    8686        srv/net/net \
    87         drv/root \
    88         drv/rootvirt
     87        drv/root
    8988
    9089## Networking
    … …  
    109108
    110109ifeq ($(UARCH),amd64)
    111         DIRS += drv/rootpc
    112         DIRS += drv/pciintel
    113         DIRS += drv/isa
    114         DIRS += drv/ns8250
    115110endif
    116111
    117112ifeq ($(UARCH),ia32)
    118         DIRS += drv/rootpc
     113        DIRS += drv/rootia32
    119114        DIRS += drv/pciintel
    120115        DIRS += drv/isa

  • uspace/drv/isa/isa.c

    rab3a851 r41a7f62  
    282282
    283283                printf(NAME ": added io range (addr=0x%x, size=0x%x) to "
    284                     "device %s\n", (unsigned int) addr, (unsigned int) len,
    285                     dev->name);
     284                    "device %s\n", addr, len, dev->name);
    286285        }
    287286}
    … …  
    490489static int isa_add_device(device_t *dev)
    491490{
    492         printf(NAME ": isa_add_device, device handle = %d\n",
    493             (int) dev->handle);
     491        printf(NAME ": isa_add_device, device handle = %d\n", dev->handle);
    494492
    495493        /* Add child devices. */

  • uspace/drv/ns8250/ns8250.c

    rab3a851 r41a7f62  
    274274       
    275275        /* Gain control over port's registers. */
    276         if (pio_enable((void *)(uintptr_t) data->io_addr, REG_COUNT,
     276        if (pio_enable((void *) data->io_addr, REG_COUNT,
    277277            (void **) &data->port)) {
    278278                printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
    … …  
    727727{
    728728        printf(NAME ": ns8250_add_device %s (handle = %d)\n",
    729             dev->name, (int) dev->handle);
     729            dev->name, dev->handle);
    730730       
    731731        int res = ns8250_dev_initialize(dev);

  • uspace/drv/pciintel/pci.c

    rab3a851 r41a7f62  
    324324                printf(NAME ": device %s : ", dev->name);
    325325                printf("address = %" PRIx64, range_addr);
    326                 printf(", size = %x\n", (unsigned int) range_size);
     326                printf(", size = %x\n", range_size);
    327327        }
    328328       
    … …  
    489489            (uint32_t) hw_resources.resources[0].res.io_range.address;
    490490       
    491         if (pio_enable((void *)(uintptr_t)bus_data->conf_io_addr, 8,
     491        if (pio_enable((void *)bus_data->conf_io_addr, 8,
    492492            &bus_data->conf_addr_port)) {
    493493                printf(NAME ": failed to enable configuration ports.\n");

  • uspace/drv/root/root.c

    rab3a851 r41a7f62  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
    3  * Copyright (c) 2010 Vojtech Horky
    43 * All rights reserved.
    54 *
    … …  
    5453#define NAME "root"
    5554
    56 #define PLATFORM_DEVICE_NAME "hw"
    57 #define PLATFORM_DEVICE_MATCH_ID STRING(UARCH)
    58 #define PLATFORM_DEVICE_MATCH_SCORE 100
    59 
    60 #define VIRTUAL_DEVICE_NAME "virt"
    61 #define VIRTUAL_DEVICE_MATCH_ID "rootvirt"
    62 #define VIRTUAL_DEVICE_MATCH_SCORE 100
    63 
    6455static int root_add_device(device_t *dev);
    6556
    … …  
    7566};
    7667
    77 /** Create the device which represents the root of virtual device tree.
    78  *
    79  * @param parent Parent of the newly created device.
    80  * @return Error code.
    81  */
    82 static int add_virtual_root_child(device_t *parent)
    83 {
    84         printf(NAME ": adding new child for virtual devices.\n");
    85         printf(NAME ":   device node is `%s' (%d %s)\n", VIRTUAL_DEVICE_NAME,
    86             VIRTUAL_DEVICE_MATCH_SCORE, VIRTUAL_DEVICE_MATCH_ID);
    87 
    88         int res = child_device_register_wrapper(parent, VIRTUAL_DEVICE_NAME,
    89             VIRTUAL_DEVICE_MATCH_ID, VIRTUAL_DEVICE_MATCH_SCORE);
    90 
    91         return res;
    92 }
    93 
    9468/** Create the device which represents the root of HW device tree.
    9569 *
    … …  
    10074{
    10175        printf(NAME ": adding new child for platform device.\n");
    102         printf(NAME ":   device node is `%s' (%d %s)\n", PLATFORM_DEVICE_NAME,
    103             PLATFORM_DEVICE_MATCH_SCORE, PLATFORM_DEVICE_MATCH_ID);
    10476       
    105         int res = child_device_register_wrapper(parent, PLATFORM_DEVICE_NAME,
    106             PLATFORM_DEVICE_MATCH_ID, PLATFORM_DEVICE_MATCH_SCORE);
    107 
     77        int res = EOK;
     78        device_t *platform = NULL;
     79        match_id_t *match_id = NULL;
     80       
     81        /* Create new device. */
     82        platform = create_device();
     83        if (NULL == platform) {
     84                res = ENOMEM;
     85                goto failure;
     86        }       
     87       
     88        platform->name = "hw";
     89        printf(NAME ": the new device's name is %s.\n", platform->name);
     90       
     91        /* Initialize match id list. */
     92        match_id = create_match_id();
     93        if (NULL == match_id) {
     94                res = ENOMEM;
     95                goto failure;
     96        }
     97       
     98        /* TODO - replace this with some better solution (sysinfo ?) */
     99        match_id->id = STRING(UARCH);
     100        match_id->score = 100;
     101        add_match_id(&platform->match_ids, match_id);
     102       
     103        /* Register child device. */
     104        res = child_device_register(platform, parent);
     105        if (EOK != res)
     106                goto failure;
     107       
     108        return res;
     109       
     110failure:
     111        if (NULL != match_id)
     112                match_id->id = NULL;
     113       
     114        if (NULL != platform) {
     115                platform->name = NULL;
     116                delete_device(platform);
     117        }
     118       
    108119        return res;
    109120}
    … …  
    119130            dev->handle);
    120131       
    121         /*
    122          * Register virtual devices root.
    123          * We ignore error occurrence because virtual devices shall not be
    124          * vital for the system.
    125          */
    126         add_virtual_root_child(dev);
    127 
    128132        /* Register root device's children. */
    129133        int res = add_platform_child(dev);

  • uspace/lib/drv/generic/driver.c

    rab3a851 r41a7f62  
    165165       
    166166        devman_handle_t dev_handle =  IPC_GET_ARG1(*icall);
    167         devman_handle_t parent_dev_handle = IPC_GET_ARG2(*icall);
    168    
    169167        device_t *dev = create_device();
    170168        dev->handle = dev_handle;
    … …  
    174172       
    175173        add_to_devices_list(dev);
    176         dev->parent = driver_get_device(&devices, parent_dev_handle);
    177        
    178174        res = driver->driver_ops->add_device(dev);
    179175        if (0 == res) {
    … …  
    381377}
    382378
    383 /** Wrapper for child_device_register for devices with single match id.
    384  *
    385  * @param parent Parent device.
    386  * @param child_name Child device name.
    387  * @param child_match_id Child device match id.
    388  * @param child_match_score Child device match score.
    389  * @return Error code.
    390  */
    391 int child_device_register_wrapper(device_t *parent, const char *child_name,
    392     const char *child_match_id, int child_match_score)
    393 {
    394         device_t *child = NULL;
    395         match_id_t *match_id = NULL;
    396         int rc;
    397 
    398         child = create_device();
    399         if (child == NULL) {
    400                 rc = ENOMEM;
    401                 goto failure;
    402         }
    403 
    404         child->name = child_name;
    405 
    406         match_id = create_match_id();
    407         if (match_id == NULL) {
    408                 rc = ENOMEM;
    409                 goto failure;
    410         }
    411 
    412         match_id->id = child_match_id;
    413         match_id->score = child_match_score;
    414         add_match_id(&child->match_ids, match_id);
    415 
    416         rc = child_device_register(child, parent);
    417         if (EOK != rc)
    418                 goto failure;
    419 
    420         goto leave;
    421 
    422 failure:
    423         if (match_id != NULL) {
    424                 match_id->id = NULL;
    425                 delete_match_id(match_id);
    426         }
    427 
    428         if (child != NULL) {
    429                 child->name = NULL;
    430                 delete_device(child);
    431         }
    432 
    433 leave:
    434         return rc;
    435 }
    436 
    437379int driver_main(driver_t *drv)
    438380{

  • uspace/lib/drv/include/driver.h

    rab3a851 r41a7f62  
    199199
    200200int child_device_register(device_t *, device_t *);
    201 int child_device_register_wrapper(device_t *, const char *, const char *, int);
    202201
    203202

  • uspace/srv/devman/devman.c

    rab3a851 r41a7f62  
    643643       
    644644        /* Send the device to the driver. */
    645         devman_handle_t parent_handle;
    646         if (node->parent) {
    647                 parent_handle = node->parent->handle;
    648         } else {
    649                 parent_handle = 0;
    650         }
    651         aid_t req = async_send_2(phone, DRIVER_ADD_DEVICE, node->handle,
    652             parent_handle, &answer);
     645        aid_t req = async_send_1(phone, DRIVER_ADD_DEVICE, node->handle,
     646            &answer);
    653647       
    654648        /* Send the device's name to the driver. */

  • uspace/srv/devman/match.c

    rab3a851 r41a7f62  
    3535#include "devman.h"
    3636
    37 /** Compute compound score of driver and device.
    38  *
    39  * @param driver Match id of the driver.
    40  * @param device Match id of the device.
    41  * @return Compound score.
    42  * @retval 0 No match at all.
    43  */
    44 static int compute_match_score(match_id_t *driver, match_id_t *device)
    45 {
    46         if (str_cmp(driver->id, device->id) == 0) {
    47                 /*
    48                  * The strings matches, return their score multiplied.
    49                  */
    50                 return driver->score * device->score;
    51         } else {
    52                 /*
    53                  * Different strings, return zero.
    54                  */
    55                 return 0;
    56         }
    57 }
    58 
    5937int get_match_score(driver_t *drv, node_t *dev)
    6038{
    … …  
    6543                return 0;
    6644       
    67         /*
    68          * Go through all pairs, return the highest score obtainetd.
    69          */
    70         int highest_score = 0;
     45        link_t *drv_link = drv->match_ids.ids.next;
     46        link_t *dev_link = dev->match_ids.ids.next;
    7147       
    72         link_t *drv_link = drv->match_ids.ids.next;
    73         while (drv_link != drv_head) {
    74                 link_t *dev_link = dev_head->next;
    75                 while (dev_link != dev_head) {
    76                         match_id_t *drv_id = list_get_instance(drv_link, match_id_t, link);
    77                         match_id_t *dev_id = list_get_instance(dev_link, match_id_t, link);
    78                        
    79                         int score = compute_match_score(drv_id, dev_id);
    80                         if (score > highest_score) {
    81                                 highest_score = score;
    82                         }
    83 
    84                         dev_link = dev_link->next;
     48        match_id_t *drv_id = list_get_instance(drv_link, match_id_t, link);
     49        match_id_t *dev_id = list_get_instance(dev_link, match_id_t, link);
     50       
     51        int score_next_drv = 0;
     52        int score_next_dev = 0;
     53       
     54        do {
     55                match_id_t *tmp_ma_id;
     56       
     57                if (str_cmp(drv_id->id, dev_id->id) == 0) {
     58                        /*
     59                         * We found a match.
     60                         * Return the score of the match.
     61                         */
     62                        return drv_id->score * dev_id->score;
    8563                }
    8664               
    87                 drv_link = drv_link->next;
    88         }
     65                /*
     66                 * Compute the next score we get, if we advance in the driver's
     67                 * list of match ids.
     68                 */
     69                if (drv_link->next != drv_head) {
     70                        tmp_ma_id = list_get_instance(drv_link->next,
     71                            match_id_t, link);
     72                        score_next_drv = dev_id->score * tmp_ma_id->score;
     73                } else {
     74                        score_next_drv = 0;
     75                }
     76               
     77                /*
     78                 * Compute the next score we get, if we advance in the device's
     79                 * list of match ids.
     80                 */
     81                if (dev_link->next != dev_head) {
     82                        tmp_ma_id = list_get_instance(dev_link->next,
     83                            match_id_t, link);
     84                        score_next_dev = drv_id->score * tmp_ma_id->score;
     85                } else {
     86                        score_next_dev = 0;
     87                }
     88               
     89                /*
     90                 * Advance in one of the two lists, so we get the next highest
     91                 * score.
     92                 */
     93                if (score_next_drv > score_next_dev) {
     94                        drv_link = drv_link->next;
     95                        drv_id = list_get_instance(drv_link, match_id_t, link);
     96                } else {
     97                        dev_link = dev_link->next;
     98                        dev_id = list_get_instance(dev_link, match_id_t, link);
     99                }
     100               
     101        } while (drv_link->next != drv_head && dev_link->next != dev_head);
    89102       
    90         return highest_score;
     103        return 0;
    91104}
    92105
Note: See TracChangeset for help on using the changeset viewer.