Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/isa/isa.c

    r301032a r3e6a98c5  
    8585        fibril_mutex_t mutex;
    8686        ddf_fun_t *fnode;
    87         hw_resource_t resources[ISA_MAX_HW_RES];
    8887        hw_resource_list_t hw_resources;
    8988        link_t bus_link;
    … …  
    104103static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
    105104{
    106         isa_fun_t *isa = isa_fun(fnode);
    107         assert(isa);
    108 
    109         return &isa->hw_resources;
    110 }
    111 
    112 static bool isa_fun_enable_interrupt(ddf_fun_t *fnode)
     105        isa_fun_t *fun = isa_fun(fnode);
     106        assert(fun != NULL);
     107
     108        return &fun->hw_resources;
     109}
     110
     111static bool isa_enable_fun_interrupt(ddf_fun_t *fnode)
    113112{
    114113        /* This is an old ugly way, copied from pci driver */
    115114        assert(fnode);
    116         isa_fun_t *isa = isa_fun(fnode);
    117         assert(isa);
     115        isa_fun_t *fun = isa_fun(fnode);
    118116
    119117        sysarg_t apic;
    … …  
    131129                return false;
    132130
    133         const hw_resource_list_t *res = &isa->hw_resources;
     131        const hw_resource_list_t *res = &fun->hw_resources;
    134132        assert(res);
    135133        for (size_t i = 0; i < res->count; ++i) {
    … …  
    153151}
    154152
    155 static int isa_fun_setup_dma(ddf_fun_t *fnode,
    156     unsigned int channel, uint32_t pa, uint32_t size, uint8_t mode)
     153static int isa_dma_channel_fun_setup(ddf_fun_t *fnode,
     154    unsigned int channel, uint32_t pa, uint16_t size, uint8_t mode)
    157155{
    158156        assert(fnode);
    159         isa_fun_t *isa = isa_fun(fnode);
    160         assert(isa);
    161         const hw_resource_list_t *res = &isa->hw_resources;
     157        isa_fun_t *fun = isa_fun(fnode);
     158        const hw_resource_list_t *res = &fun->hw_resources;
    162159        assert(res);
    163 
     160       
     161        const unsigned int ch = channel;
    164162        for (size_t i = 0; i < res->count; ++i) {
    165                 /* Check for assigned channel */
    166163                if (((res->resources[i].type == DMA_CHANNEL_16) &&
    167                     (res->resources[i].res.dma_channel.dma16 == channel)) ||
     164                    (res->resources[i].res.dma_channel.dma16 == ch)) ||
    168165                    ((res->resources[i].type == DMA_CHANNEL_8) &&
    169                     (res->resources[i].res.dma_channel.dma8 == channel))) {
    170                         return dma_channel_setup(channel, pa, size, mode);
     166                    (res->resources[i].res.dma_channel.dma8 == ch))) {
     167                        return dma_setup_channel(channel, pa, size, mode);
    171168                }
    172169        }
    173 
    174         return EINVAL;
    175 }
    176 
    177 static int isa_fun_remain_dma(ddf_fun_t *fnode,
    178     unsigned channel, size_t *size)
    179 {
    180         assert(size);
    181         assert(fnode);
    182         isa_fun_t *isa = isa_fun(fnode);
    183         assert(isa);
    184         const hw_resource_list_t *res = &isa->hw_resources;
    185         assert(res);
    186 
    187         for (size_t i = 0; i < res->count; ++i) {
    188                 /* Check for assigned channel */
    189                 if (((res->resources[i].type == DMA_CHANNEL_16) &&
    190                     (res->resources[i].res.dma_channel.dma16 == channel)) ||
    191                     ((res->resources[i].type == DMA_CHANNEL_8) &&
    192                     (res->resources[i].res.dma_channel.dma8 == channel))) {
    193                         return dma_channel_remain(channel, size);
    194                 }
    195         }
    196 
     170       
    197171        return EINVAL;
    198172}
    … …  
    200174static hw_res_ops_t isa_fun_hw_res_ops = {
    201175        .get_resource_list = isa_get_fun_resources,
    202         .enable_interrupt = isa_fun_enable_interrupt,
    203         .dma_channel_setup = isa_fun_setup_dma,
    204         .dma_channel_remain = isa_fun_remain_dma,
     176        .enable_interrupt = isa_enable_fun_interrupt,
     177        .dma_channel_setup = isa_dma_channel_fun_setup,
    205178};
    206179
    207 static ddf_dev_ops_t isa_fun_ops= {
    208         .interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops,
    209 };
     180static ddf_dev_ops_t isa_fun_ops;
    210181
    211182static int isa_dev_add(ddf_dev_t *dev);
    … …  
    241212
    242213        fibril_mutex_initialize(&fun->mutex);
    243         fun->hw_resources.resources = fun->resources;
    244 
    245214        fun->fnode = fnode;
    246215        return fun;
    … …  
    301270{
    302271        char *line = str;
    303         *next = NULL;
    304272
    305273        if (str == NULL) {
     274                *next = NULL;
    306275                return NULL;
    307276        }
    … …  
    313282        if (*str != '\0') {
    314283                *next = str + 1;
     284        } else {
     285                *next = NULL;
    315286        }
    316287
    … …  
    339310        /* Get the name part of the rest of the line. */
    340311        strtok(line, ":");
    341         return line;
    342 }
    343 
    344 static inline const char *skip_spaces(const char *line)
     312
     313        /* Allocate output buffer. */
     314        size_t size = str_size(line) + 1;
     315        char *name = malloc(size);
     316
     317        if (name != NULL) {
     318                /* Copy the result to the output buffer. */
     319                str_cpy(name, size, line);
     320        }
     321
     322        return name;
     323}
     324
     325static inline char *skip_spaces(char *line)
    345326{
    346327        /* Skip leading spaces. */
    … …  
    351332}
    352333
    353 static void isa_fun_add_irq(isa_fun_t *fun, int irq)
     334static void isa_fun_set_irq(isa_fun_t *fun, int irq)
    354335{
    355336        size_t count = fun->hw_resources.count;
    … …  
    367348}
    368349
    369 static void isa_fun_add_dma(isa_fun_t *fun, int dma)
     350static void isa_fun_set_dma(isa_fun_t *fun, int dma)
    370351{
    371352        size_t count = fun->hw_resources.count;
    … …  
    400381}
    401382
    402 static void isa_fun_add_io_range(isa_fun_t *fun, size_t addr, size_t len)
     383static void isa_fun_set_io_range(isa_fun_t *fun, size_t addr, size_t len)
    403384{
    404385        size_t count = fun->hw_resources.count;
    … …  
    419400}
    420401
    421 static void fun_parse_irq(isa_fun_t *fun, const char *val)
     402static void fun_parse_irq(isa_fun_t *fun, char *val)
    422403{
    423404        int irq = 0;
    … …  
    428409
    429410        if (val != end)
    430                 isa_fun_add_irq(fun, irq);
    431 }
    432 
    433 static void fun_parse_dma(isa_fun_t *fun, const char *val)
    434 {
     411                isa_fun_set_irq(fun, irq);
     412}
     413
     414static void fun_parse_dma(isa_fun_t *fun, char *val)
     415{
     416        unsigned int dma = 0;
    435417        char *end = NULL;
    436418       
    437419        val = skip_spaces(val);
    438         const int dma = strtol(val, &end, 10);
     420        dma = (unsigned int) strtol(val, &end, 10);
    439421       
    440422        if (val != end)
    441                 isa_fun_add_dma(fun, dma);
    442 }
    443 
    444 static void fun_parse_io_range(isa_fun_t *fun, const char *val)
     423                isa_fun_set_dma(fun, dma);
     424}
     425
     426static void fun_parse_io_range(isa_fun_t *fun, char *val)
    445427{
    446428        size_t addr, len;
    … …  
    459441                return;
    460442
    461         isa_fun_add_io_range(fun, addr, len);
    462 }
    463 
    464 static void get_match_id(char **id, const char *val)
    465 {
    466         const char *end = val;
     443        isa_fun_set_io_range(fun, addr, len);
     444}
     445
     446static void get_match_id(char **id, char *val)
     447{
     448        char *end = val;
    467449
    468450        while (!isspace(*end))
    … …  
    474456}
    475457
    476 static void fun_parse_match_id(isa_fun_t *fun, const char *val)
     458static void fun_parse_match_id(isa_fun_t *fun, char *val)
    477459{
    478460        char *id = NULL;
     461        int score = 0;
    479462        char *end = NULL;
     463        int rc;
    480464
    481465        val = skip_spaces(val);
    482466
    483         int score = (int)strtol(val, &end, 10);
     467        score = (int)strtol(val, &end, 10);
    484468        if (val == end) {
    485469                ddf_msg(LVL_ERROR, "Cannot read match score for function "
    … …  
    499483            "function %s", id, score, ddf_fun_get_name(fun->fnode));
    500484
    501         int rc = ddf_fun_add_match_id(fun->fnode, id, score);
     485        rc = ddf_fun_add_match_id(fun->fnode, id, score);
    502486        if (rc != EOK) {
    503487                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
    … …  
    508492}
    509493
    510 static bool prop_parse(isa_fun_t *fun, const char *line, const char *prop,
    511     void (*read_fn)(isa_fun_t *, const char *))
     494static bool prop_parse(isa_fun_t *fun, char *line, const char *prop,
     495    void (*read_fn)(isa_fun_t *, char *))
    512496{
    513497        size_t proplen = str_size(prop);
    … …  
    524508}
    525509
    526 static void fun_prop_parse(isa_fun_t *fun, const char *line)
     510static void fun_prop_parse(isa_fun_t *fun, char *line)
    527511{
    528512        /* Skip leading spaces. */
    … …  
    539523}
    540524
     525static void fun_hw_res_alloc(isa_fun_t *fun)
     526{
     527        fun->hw_resources.resources =
     528            (hw_resource_t *) malloc(sizeof(hw_resource_t) * ISA_MAX_HW_RES);
     529}
     530
     531static void fun_hw_res_free(isa_fun_t *fun)
     532{
     533        free(fun->hw_resources.resources);
     534        fun->hw_resources.resources = NULL;
     535}
     536
    541537static char *isa_fun_read_info(char *fun_conf, isa_bus_t *isa)
    542538{
    543539        char *line;
     540        char *fun_name = NULL;
    544541
    545542        /* Skip empty lines. */
    546         do {
     543        while (true) {
    547544                line = str_get_line(fun_conf, &fun_conf);
    548545
    … …  
    552549                }
    553550
    554         } while (line_empty(line));
     551                if (!line_empty(line))
     552                        break;
     553        }
    555554
    556555        /* Get device name. */
    557         const char *fun_name = get_device_name(line);
     556        fun_name = get_device_name(line);
    558557        if (fun_name == NULL)
    559558                return NULL;
    560559
    561560        isa_fun_t *fun = isa_fun_create(isa, fun_name);
     561        free(fun_name);
    562562        if (fun == NULL) {
    563563                return NULL;
    564564        }
     565
     566        /* Allocate buffer for the list of hardware resources of the device. */
     567        fun_hw_res_alloc(fun);
    565568
    566569        /* Get properties of the device (match ids, irq and io range). */
    … …  
    593596}
    594597
    595 static void isa_functions_add(isa_bus_t *isa)
    596 {
    597         char *conf = fun_conf_read(CHILD_FUN_CONF_PATH);
     598static void fun_conf_parse(char *conf, isa_bus_t *isa)
     599{
    598600        while (conf != NULL && *conf != '\0') {
    599601                conf = isa_fun_read_info(conf, isa);
    600602        }
    601         free(conf);
     603}
     604
     605static void isa_functions_add(isa_bus_t *isa)
     606{
     607        char *fun_conf;
     608
     609        fun_conf = fun_conf_read(CHILD_FUN_CONF_PATH);
     610        if (fun_conf != NULL) {
     611                fun_conf_parse(fun_conf, isa);
     612                free(fun_conf);
     613        }
    602614}
    603615
    604616static int isa_dev_add(ddf_dev_t *dev)
    605617{
     618        isa_bus_t *isa;
     619
    606620        ddf_msg(LVL_DEBUG, "isa_dev_add, device handle = %d",
    607621            (int) ddf_dev_get_handle(dev));
    608622
    609         isa_bus_t *isa = ddf_dev_data_alloc(dev, sizeof(isa_bus_t));
     623        isa = ddf_dev_data_alloc(dev, sizeof(isa_bus_t));
    610624        if (isa == NULL)
    611625                return ENOMEM;
    … …  
    644658{
    645659        isa_bus_t *isa = isa_bus(dev);
     660        int rc;
    646661
    647662        fibril_mutex_lock(&isa->mutex);
    … …  
    651666                    isa_fun_t, bus_link);
    652667
    653                 int rc = ddf_fun_offline(fun->fnode);
     668                rc = ddf_fun_offline(fun->fnode);
    654669                if (rc != EOK) {
    655670                        fibril_mutex_unlock(&isa->mutex);
    … …  
    667682                list_remove(&fun->bus_link);
    668683
     684                fun_hw_res_free(fun);
    669685                ddf_fun_destroy(fun->fnode);
    670686        }
    … …  
    693709}
    694710
     711
     712static void isa_init()
     713{
     714        ddf_log_init(NAME);
     715        isa_fun_ops.interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops;
     716}
     717
    695718int main(int argc, char *argv[])
    696719{
    697720        printf(NAME ": HelenOS ISA bus driver\n");
    698         ddf_log_init(NAME);
     721        isa_init();
    699722        return ddf_driver_main(&isa_driver);
    700723}
Note: See TracChangeset for help on using the changeset viewer.