Changeset eb1a2f4 in mainline for uspace/lib/drv


Ignore:
Timestamp:
2011-02-22T23:30:56Z (14 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3b5d1535, a9c674e0
Parents:
dbe25f1 (diff), 664af708 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes (DDF refactoring)

This merge includes DDF refactoring that brought multifunctional devices
(i.e. ddf_dev_t and ddf_fun_t). Please, see ticket #295 at HelenOS
upstream Trac.

The conflicts themselves were easy to solve (merely several renamings).

Changes to USB subsystem:

  • drivers uses ddf_dev_t and ddf_fun_t
  • different signatures of many library functions
  • several hacks around communication with parent device (now the communication is clearer and somehow what we have now is hack about other hacks)
    • will repair and clean later
  • maybe added some extra debugging messages (the diff has about 240K, and I admit I have no energy to double check that)

WARNING:

  • the diff is VERY long, recommended is viewing partial diffs of the merge (i.e. merges in mainline branch that lead to the parent one)
  • merging with your branches might involve huge renamings, sorry, no other way is possible

BUGS:

  • hub driver will not work (no function created)

GOOD NEWS:

  • QEMU keyboard seems to work with QEMU 0.13 and 0.14
  • we are up-to-date with mainline again
Location:
uspace/lib/drv
Files:
1 added
10 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    rdbe25f1 reb1a2f4  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4950#include <errno.h>
    5051#include <inttypes.h>
     52#include <devman.h>
    5153
    5254#include <ipc/driver.h>
    5355
    5456#include "dev_iface.h"
    55 #include "driver.h"
     57#include "ddf/driver.h"
     58#include "ddf/interrupt.h"
    5659
    5760/** Driver structure */
    … …  
    5962
    6063/** Devices */
    61 LIST_INITIALIZE(devices);
    62 FIBRIL_MUTEX_INITIALIZE(devices_mutex);
     64LIST_INITIALIZE(functions);
     65FIBRIL_MUTEX_INITIALIZE(functions_mutex);
    6366
    6467/** Interrupts */
    … …  
    7679};
    7780
     81static ddf_dev_t *create_device(void);
     82static void delete_device(ddf_dev_t *);
     83static remote_handler_t *function_get_default_handler(ddf_fun_t *);
     84static void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t);
    7885
    7986static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
    … …  
    150157
    151158interrupt_context_t *
    152 find_interrupt_context(interrupt_context_list_t *list, device_t *dev, int irq)
     159find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq)
    153160{
    154161        fibril_mutex_lock(&list->mutex);
    … …  
    172179
    173180int
    174 register_interrupt_handler(device_t *dev, int irq, interrupt_handler_t *handler,
     181register_interrupt_handler(ddf_dev_t *dev, int irq, interrupt_handler_t *handler,
    175182    irq_code_t *pseudocode)
    176183{
    … …  
    195202}
    196203
    197 int unregister_interrupt_handler(device_t *dev, int irq)
     204int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
    198205{
    199206        interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
    … …  
    209216}
    210217
    211 static void add_to_devices_list(device_t *dev)
    212 {
    213         fibril_mutex_lock(&devices_mutex);
    214         list_append(&dev->link, &devices);
    215         fibril_mutex_unlock(&devices_mutex);
    216 }
    217 
    218 static void remove_from_devices_list(device_t *dev)
    219 {
    220         fibril_mutex_lock(&devices_mutex);
    221         list_remove(&dev->link);
    222         fibril_mutex_unlock(&devices_mutex);
    223 }
    224 
    225 static device_t *driver_get_device(link_t *devices, devman_handle_t handle)
    226 {
    227         device_t *dev = NULL;
    228        
    229         fibril_mutex_lock(&devices_mutex);
    230         link_t *link = devices->next;
    231        
    232         while (link != devices) {
    233                 dev = list_get_instance(link, device_t, link);
    234                 if (dev->handle == handle) {
    235                         fibril_mutex_unlock(&devices_mutex);
    236                         return dev;
     218static void add_to_functions_list(ddf_fun_t *fun)
     219{
     220        fibril_mutex_lock(&functions_mutex);
     221        list_append(&fun->link, &functions);
     222        fibril_mutex_unlock(&functions_mutex);
     223}
     224
     225static void remove_from_functions_list(ddf_fun_t *fun)
     226{
     227        fibril_mutex_lock(&functions_mutex);
     228        list_remove(&fun->link);
     229        fibril_mutex_unlock(&functions_mutex);
     230}
     231
     232static ddf_fun_t *driver_get_function(link_t *functions, devman_handle_t handle)
     233{
     234        ddf_fun_t *fun = NULL;
     235       
     236        fibril_mutex_lock(&functions_mutex);
     237        link_t *link = functions->next;
     238       
     239        while (link != functions) {
     240                fun = list_get_instance(link, ddf_fun_t, link);
     241                if (fun->handle == handle) {
     242                        fibril_mutex_unlock(&functions_mutex);
     243                        return fun;
    237244                }
     245               
    238246                link = link->next;
    239247        }
    240248       
    241         fibril_mutex_unlock(&devices_mutex);
     249        fibril_mutex_unlock(&functions_mutex);
    242250       
    243251        return NULL;
    … …  
    250258       
    251259        devman_handle_t dev_handle = IPC_GET_ARG1(*icall);
    252         devman_handle_t parent_dev_handle = IPC_GET_ARG2(*icall);
    253        
    254         device_t *dev = create_device();
     260        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
     261       
     262        ddf_dev_t *dev = create_device();
    255263        dev->handle = dev_handle;
    256        
     264
    257265        async_data_write_accept((void **) &dev_name, true, 0, 0, 0, 0);
    258266        dev->name = dev_name;
    259        
    260         add_to_devices_list(dev);
    261         dev->parent = driver_get_device(&devices, parent_dev_handle);
     267
     268        /*
     269         * Currently not used, parent fun handle is stored in context
     270         * of the connection to the parent device driver.
     271         */
     272        (void) parent_fun_handle;
    262273       
    263274        res = driver->driver_ops->add_device(dev);
    … …  
    268279                printf("%s: failed to add a new device with handle = %" PRIun ".\n",
    269280                    driver->name, dev_handle);
    270                 remove_from_devices_list(dev);
    271281                delete_device(dev);
    272282        }
    … …  
    311321         */
    312322        devman_handle_t handle = IPC_GET_ARG2(*icall);
    313         device_t *dev = driver_get_device(&devices, handle);
    314 
    315         if (dev == NULL) {
    316                 printf("%s: driver_connection_gen error - no device with handle"
     323        ddf_fun_t *fun = driver_get_function(&functions, handle);
     324
     325        if (fun == NULL) {
     326                printf("%s: driver_connection_gen error - no function with handle"
    317327                    " %" PRIun " was found.\n", driver->name, handle);
    318328                async_answer_0(iid, ENOENT);
    … …  
    327337       
    328338        int ret = EOK;
    329         /* open the device */
    330         if (dev->ops != NULL && dev->ops->open != NULL)
    331                 ret = (*dev->ops->open)(dev);
     339        /* Open device function */
     340        if (fun->ops != NULL && fun->ops->open != NULL)
     341                ret = (*fun->ops->open)(fun);
    332342       
    333343        async_answer_0(iid, ret);
    … …  
    344354                switch  (method) {
    345355                case IPC_M_PHONE_HUNGUP:
    346                         /* close the device */
    347                         if (dev->ops != NULL && dev->ops->close != NULL)
    348                                 (*dev->ops->close)(dev);
     356                        /* Close device function */
     357                        if (fun->ops != NULL && fun->ops->close != NULL)
     358                                (*fun->ops->close)(fun);
    349359                        async_answer_0(callid, EOK);
    350360                        return;
    … …  
    356366                        if (!is_valid_iface_idx(iface_idx)) {
    357367                                remote_handler_t *default_handler =
    358                                     device_get_default_handler(dev);
     368                                    function_get_default_handler(fun);
    359369                                if (default_handler != NULL) {
    360                                         (*default_handler)(dev, callid, &call);
     370                                        (*default_handler)(fun, callid, &call);
    361371                                        break;
    362372                                }
     373                               
    363374                                /*
    364                                  * This is not device's interface and the
     375                                 * Function has no such interface and
    365376                                 * default handler is not provided.
    366377                                 */
    … …  
    372383                        }
    373384                       
    374                         /* calling one of the device's interfaces */
     385                        /* calling one of the function's interfaces */
    375386                       
    376387                        /* Get the interface ops structure. */
    377                         void *ops = device_get_ops(dev, iface_idx);
     388                        void *ops = function_get_ops(fun, iface_idx);
    378389                        if (ops == NULL) {
    379390                                printf("%s: driver_connection_gen error - ",
    380391                                    driver->name);
    381                                 printf("device with handle %" PRIun " has no interface "
     392                                printf("Function with handle %" PRIun " has no interface "
    382393                                    "with id %d.\n", handle, iface_idx);
    383394                                async_answer_0(callid, ENOTSUP);
    … …  
    408419                         * receive parameters from the remote client and it will
    409420                         * pass it to the corresponding local interface method
    410                          * associated with the device by its driver.
     421                         * associated with the function by its driver.
    411422                         */
    412                         (*iface_method_ptr)(dev, ops, callid, &call);
     423                        (*iface_method_ptr)(fun, ops, callid, &call);
    413424                        break;
    414425                }
    … …  
    425436        driver_connection_gen(iid, icall, false);
    426437}
    427 
    428438
    429439/** Function for handling connections to device driver. */
    … …  
    454464 * @return              The device structure.
    455465 */
    456 device_t *create_device(void)
    457 {
    458         device_t *dev = malloc(sizeof(device_t));
    459 
    460         if (dev != NULL) {
    461                 memset(dev, 0, sizeof(device_t));
    462                 init_match_ids(&dev->match_ids);
    463         }
    464 
     466static ddf_dev_t *create_device(void)
     467{
     468        ddf_dev_t *dev;
     469
     470        dev = malloc(sizeof(ddf_dev_t));
     471        if (dev == NULL)
     472                return NULL;
     473
     474        memset(dev, 0, sizeof(ddf_dev_t));
    465475        return dev;
    466476}
    467477
     478/** Create new function structure.
     479 *
     480 * @return              The device structure.
     481 */
     482static ddf_fun_t *create_function(void)
     483{
     484        ddf_fun_t *fun;
     485
     486        fun = calloc(1, sizeof(ddf_fun_t));
     487        if (fun == NULL)
     488                return NULL;
     489
     490        init_match_ids(&fun->match_ids);
     491        link_initialize(&fun->link);
     492
     493        return fun;
     494}
     495
    468496/** Delete device structure.
    469497 *
    470498 * @param dev           The device structure.
    471499 */
    472 void delete_device(device_t *dev)
    473 {
    474         clean_match_ids(&dev->match_ids);
    475         if (dev->name != NULL)
    476                 free(dev->name);
     500static void delete_device(ddf_dev_t *dev)
     501{
    477502        free(dev);
    478503}
    479504
    480 void *device_get_ops(device_t *dev, dev_inferface_idx_t idx)
     505/** Delete device structure.
     506 *
     507 * @param dev           The device structure.
     508 */
     509static void delete_function(ddf_fun_t *fun)
     510{
     511        clean_match_ids(&fun->match_ids);
     512        if (fun->name != NULL)
     513                free(fun->name);
     514        free(fun);
     515}
     516
     517/** Create a DDF function node.
     518 *
     519 * Create a DDF function (in memory). Both child devices and external clients
     520 * communicate with a device via its functions.
     521 *
     522 * The created function node is fully formed, but only exists in the memory
     523 * of the client task. In order to be visible to the system, the function
     524 * must be bound using ddf_fun_bind().
     525 *
     526 * This function should only fail if there is not enough free memory.
     527 * Specifically, this function succeeds even if @a dev already has
     528 * a (bound) function with the same name.
     529 *
     530 * Type: A function of type fun_inner indicates that DDF should attempt
     531 * to attach child devices to the function. fun_exposed means that
     532 * the function should be exported to external clients (applications).
     533 *
     534 * @param dev           Device to which we are adding function
     535 * @param ftype         Type of function (fun_inner or fun_exposed)
     536 * @param name          Name of function
     537 *
     538 * @return              New function or @c NULL if memory is not available
     539 */
     540ddf_fun_t *ddf_fun_create(ddf_dev_t *dev, fun_type_t ftype, const char *name)
     541{
     542        ddf_fun_t *fun;
     543
     544        fun = create_function();
     545        if (fun == NULL)
     546                return NULL;
     547
     548        fun->bound = false;
     549        fun->dev = dev;
     550        fun->ftype = ftype;
     551
     552        fun->name = str_dup(name);
     553        if (fun->name == NULL) {
     554                delete_function(fun);
     555                return NULL;
     556        }
     557
     558        return fun;
     559}
     560
     561/** Destroy DDF function node.
     562 *
     563 * Destroy a function previously created with ddf_fun_create(). The function
     564 * must not be bound.
     565 *
     566 * @param fun           Function to destroy
     567 */
     568void ddf_fun_destroy(ddf_fun_t *fun)
     569{
     570        assert(fun->bound == false);
     571        delete_function(fun);
     572}
     573
     574static void *function_get_ops(ddf_fun_t *fun, dev_inferface_idx_t idx)
    481575{
    482576        assert(is_valid_iface_idx(idx));
    483         if (dev->ops == NULL)
     577        if (fun->ops == NULL)
    484578                return NULL;
    485         return dev->ops->interfaces[idx];
    486 }
    487 
    488 int child_device_register(device_t *child, device_t *parent)
    489 {
    490         assert(child->name != NULL);
     579        return fun->ops->interfaces[idx];
     580}
     581
     582/** Bind a function node.
     583 *
     584 * Bind the specified function to the system. This effectively makes
     585 * the function visible to the system (uploads it to the server).
     586 *
     587 * This function can fail for several reasons. Specifically,
     588 * it will fail if the device already has a bound function of
     589 * the same name.
     590 *
     591 * @param fun           Function to bind
     592 * @return              EOK on success or negative error code
     593 */
     594int ddf_fun_bind(ddf_fun_t *fun)
     595{
     596        assert(fun->name != NULL);
    491597       
    492598        int res;
    493599       
    494         add_to_devices_list(child);
    495         res = devman_child_device_register(child->name, &child->match_ids,
    496             parent->handle, &child->handle);
     600        add_to_functions_list(fun);
     601        res = devman_add_function(fun->name, fun->ftype, &fun->match_ids,
     602            fun->dev->handle, &fun->handle);
    497603        if (res != EOK) {
    498                 remove_from_devices_list(child);
     604                remove_from_functions_list(fun);
    499605                return res;
    500606        }
    501607       
     608        fun->bound = true;
    502609        return res;
    503610}
    504611
    505 /** Wrapper for child_device_register for devices with single match id.
    506  *
    507  * @param parent Parent device.
    508  * @param child_name Child device name.
    509  * @param child_match_id Child device match id.
    510  * @param child_match_score Child device match score.
    511  * @return Error code.
    512  */
    513 int child_device_register_wrapper(device_t *parent, const char *child_name,
    514     const char *child_match_id, int child_match_score,
    515     devman_handle_t *child_handle)
    516 {
    517         device_t *child = NULL;
    518         match_id_t *match_id = NULL;
    519         int rc;
    520        
    521         child = create_device();
    522         if (child == NULL) {
    523                 rc = ENOMEM;
    524                 goto failure;
    525         }
    526        
    527         child->name = child_name;
     612/** Add single match ID to inner function.
     613 *
     614 * Construct and add a single match ID to the specified function.
     615 * Cannot be called when the function node is bound.
     616 *
     617 * @param fun                   Function
     618 * @param match_id_str          Match string
     619 * @param match_score           Match score
     620 * @return                      EOK on success, ENOMEM if out of memory.
     621 */
     622int ddf_fun_add_match_id(ddf_fun_t *fun, const char *match_id_str,
     623    int match_score)
     624{
     625        match_id_t *match_id;
     626       
     627        assert(fun->bound == false);
     628        assert(fun->ftype == fun_inner);
    528629       
    529630        match_id = create_match_id();
    530         if (match_id == NULL) {
    531                 rc = ENOMEM;
    532                 goto failure;
    533         }
    534        
    535         match_id->id = child_match_id;
    536         match_id->score = child_match_score;
    537         add_match_id(&child->match_ids, match_id);
    538        
    539         rc = child_device_register(child, parent);
    540         if (rc != EOK)
    541                 goto failure;
    542 
    543         if (child_handle != NULL) {
    544                 *child_handle = child->handle;
    545         }
    546 
     631        if (match_id == NULL)
     632                return ENOMEM;
     633       
     634        match_id->id = match_id_str;
     635        match_id->score = 90;
     636       
     637        add_match_id(&fun->match_ids, match_id);
    547638        return EOK;
    548        
    549 failure:
    550         if (match_id != NULL) {
    551                 match_id->id = NULL;
    552                 delete_match_id(match_id);
    553         }
    554        
    555         if (child != NULL) {
    556                 child->name = NULL;
    557                 delete_device(child);
    558         }
    559        
    560         return rc;
    561639}
    562640
    563641/** Get default handler for client requests */
    564 remote_handler_t *device_get_default_handler(device_t *dev)
    565 {
    566         if (dev->ops == NULL)
     642static remote_handler_t *function_get_default_handler(ddf_fun_t *fun)
     643{
     644        if (fun->ops == NULL)
    567645                return NULL;
    568         return dev->ops->default_handler;
    569 }
    570 
    571 int add_device_to_class(device_t *dev, const char *class_name)
    572 {
    573         return devman_add_device_to_class(dev->handle, class_name);
    574 }
    575 
    576 int driver_main(driver_t *drv)
     646        return fun->ops->default_handler;
     647}
     648
     649/** Add exposed function to class.
     650 *
     651 * Must only be called when the function is bound.
     652 */
     653int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name)
     654{
     655        assert(fun->bound == true);
     656        assert(fun->ftype == fun_exposed);
     657       
     658        return devman_add_device_to_class(fun->handle, class_name);
     659}
     660
     661int ddf_driver_main(driver_t *drv)
    577662{
    578663        /*

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

    rdbe25f1 reb1a2f4  
    3737
    3838#include "ops/char_dev.h"
    39 #include "driver.h"
     39#include "ddf/driver.h"
    4040
    4141#define MAX_CHAR_RW_COUNT 256
    4242
    43 static void remote_char_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
    44 static void remote_char_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
     43static void remote_char_read(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     44static void remote_char_write(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4545
    4646/** Remote character interface operations. */
    … …  
    6767 * local interface to the remote client.
    6868 *
    69  * @param dev           The device from which the data are read.
     69 * @param fun           The function from which the data are read.
    7070 * @param ops           The local ops structure.
    7171 */
    7272static void
    73 remote_char_read(device_t *dev, void *ops, ipc_callid_t callid,
     73remote_char_read(ddf_fun_t *fun, void *ops, ipc_callid_t callid,
    7474    ipc_call_t *call)
    7575{
    … …  
    9494       
    9595        char buf[MAX_CHAR_RW_COUNT];
    96         int ret = (*char_dev_ops->read)(dev, buf, len);
     96        int ret = (*char_dev_ops->read)(fun, buf, len);
    9797       
    9898        if (ret < 0) {
    … …  
    114114 * local interface to the remote client.
    115115 *
    116  * @param dev           The device to which the data are written.
     116 * @param fun           The function to which the data are written.
    117117 * @param ops           The local ops structure.
    118118 */
    119119static void
    120 remote_char_write(device_t *dev, void *ops, ipc_callid_t callid,
     120remote_char_write(ddf_fun_t *fun, void *ops, ipc_callid_t callid,
    121121    ipc_call_t *call)
    122122{
    … …  
    144144        async_data_write_finalize(cid, buf, len);
    145145       
    146         int ret = (*char_dev_ops->write)(dev, buf, len);
     146        int ret = (*char_dev_ops->write)(fun, buf, len);
    147147        if (ret < 0) {
    148148                /* Some error occured. */

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

    rdbe25f1 reb1a2f4  
    3737
    3838#include "ops/hw_res.h"
    39 #include "driver.h"
     39#include "ddf/driver.h"
    4040
    41 static void remote_hw_res_get_resource_list(device_t *, void *, ipc_callid_t,
     41static void remote_hw_res_get_resource_list(ddf_fun_t *, void *, ipc_callid_t,
    4242    ipc_call_t *);
    43 static void remote_hw_res_enable_interrupt(device_t *, void *, ipc_callid_t,
     43static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, ipc_callid_t,
    4444    ipc_call_t *);
    4545
    … …  
    5555};
    5656
    57 static void remote_hw_res_enable_interrupt(device_t *dev, void *ops,
     57static void remote_hw_res_enable_interrupt(ddf_fun_t *fun, void *ops,
    5858    ipc_callid_t callid, ipc_call_t *call)
    5959{
    … …  
    6262        if (hw_res_ops->enable_interrupt == NULL)
    6363                async_answer_0(callid, ENOTSUP);
    64         else if (hw_res_ops->enable_interrupt(dev))
     64        else if (hw_res_ops->enable_interrupt(fun))
    6565                async_answer_0(callid, EOK);
    6666        else
    … …  
    6868}
    6969
    70 static void remote_hw_res_get_resource_list(device_t *dev, void *ops,
     70static void remote_hw_res_get_resource_list(ddf_fun_t *fun, void *ops,
    7171    ipc_callid_t callid, ipc_call_t *call)
    7272{
    … …  
    7878        }
    7979       
    80         hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(dev);
     80        hw_resource_list_t *hw_resources = hw_res_ops->get_resource_list(fun);
    8181        if (hw_resources == NULL){
    8282                async_answer_0(callid, ENOENT);

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

    rdbe25f1 reb1a2f4  
    3737
    3838#include "usb_iface.h"
    39 #include "driver.h"
     39#include "ddf/driver.h"
    4040
    4141
    42 static void remote_usb_get_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    43 static void remote_usb_get_interface(device_t *, void *, ipc_callid_t, ipc_call_t *);
    44 static void remote_usb_get_hc_handle(device_t *, void *, ipc_callid_t, ipc_call_t *);
     42static void remote_usb_get_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     43static void remote_usb_get_interface(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     44static void remote_usb_get_hc_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    4545//static void remote_usb(device_t *, void *, ipc_callid_t, ipc_call_t *);
    4646
    … …  
    6161
    6262
    63 void remote_usb_get_address(device_t *device, void *iface,
     63void remote_usb_get_address(ddf_fun_t *fun, void *iface,
    6464    ipc_callid_t callid, ipc_call_t *call)
    6565{
    … …  
    7474
    7575        usb_address_t address;
    76         int rc = usb_iface->get_address(device, handle, &address);
     76        int rc = usb_iface->get_address(fun, handle, &address);
    7777        if (rc != EOK) {
    7878                async_answer_0(callid, rc);
    … …  
    8282}
    8383
    84 void remote_usb_get_interface(device_t *device, void *iface,
     84void remote_usb_get_interface(ddf_fun_t *fun, void *iface,
    8585    ipc_callid_t callid, ipc_call_t *call)
    8686{
    … …  
    9595
    9696        int iface_no;
    97         int rc = usb_iface->get_interface(device, handle, &iface_no);
     97        int rc = usb_iface->get_interface(fun, handle, &iface_no);
    9898        if (rc != EOK) {
    9999                async_answer_0(callid, rc);
    … …  
    103103}
    104104
    105 void remote_usb_get_hc_handle(device_t *device, void *iface,
     105void remote_usb_get_hc_handle(ddf_fun_t *fun, void *iface,
    106106    ipc_callid_t callid, ipc_call_t *call)
    107107{
    … …  
    114114
    115115        devman_handle_t handle;
    116         int rc = usb_iface->get_hc_handle(device, &handle);
     116        int rc = usb_iface->get_hc_handle(fun, &handle);
    117117        if (rc != EOK) {
    118118                async_answer_0(callid, rc);

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

    rdbe25f1 reb1a2f4  
    3535#include <async.h>
    3636#include <errno.h>
     37#include <assert.h>
    3738
    3839#include "usbhc_iface.h"
    39 #include "driver.h"
     40#include "ddf/driver.h"
    4041
    4142#define USB_MAX_PAYLOAD_SIZE 1020
    … …  
    4344#define HACK_MAX_PACKET_SIZE_INTERRUPT_IN 4
    4445
    45 static void remote_usbhc_interrupt_out(device_t *, void *, ipc_callid_t, ipc_call_t *);
    46 static void remote_usbhc_interrupt_in(device_t *, void *, ipc_callid_t, ipc_call_t *);
    47 static void remote_usbhc_bulk_out(device_t *, void *, ipc_callid_t, ipc_call_t *);
    48 static void remote_usbhc_bulk_in(device_t *, void *, ipc_callid_t, ipc_call_t *);
    49 static void remote_usbhc_control_write(device_t *, void *, ipc_callid_t, ipc_call_t *);
    50 static void remote_usbhc_control_read(device_t *, void *, ipc_callid_t, ipc_call_t *);
    51 static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    52 static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    53 static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    54 static void remote_usbhc_bind_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    55 static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    56 //static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
     46static void remote_usbhc_interrupt_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     47static void remote_usbhc_interrupt_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     48static void remote_usbhc_bulk_out(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     49static void remote_usbhc_bulk_in(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     50static void remote_usbhc_control_write(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     51static void remote_usbhc_control_read(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     52static void remote_usbhc_reserve_default_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     53static void remote_usbhc_release_default_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     54static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     55static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     56static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     57//static void remote_usbhc(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    5758
    5859/** Remote USB host controller interface operations. */
    … …  
    123124}
    124125
    125 void remote_usbhc_reserve_default_address(device_t *device, void *iface,
     126void remote_usbhc_reserve_default_address(ddf_fun_t *fun, void *iface,
    126127    ipc_callid_t callid, ipc_call_t *call)
    127128{
    … …  
    135136        usb_speed_t speed = DEV_IPC_GET_ARG1(*call);
    136137       
    137         int rc = usb_iface->reserve_default_address(device, speed);
     138        int rc = usb_iface->reserve_default_address(fun, speed);
    138139
    139140        async_answer_0(callid, rc);
    140141}
    141142
    142 void remote_usbhc_release_default_address(device_t *device, void *iface,
     143void remote_usbhc_release_default_address(ddf_fun_t *fun, void *iface,
    143144    ipc_callid_t callid, ipc_call_t *call)
    144145{
    … …  
    150151        }
    151152
    152         int rc = usb_iface->release_default_address(device);
     153        int rc = usb_iface->release_default_address(fun);
    153154
    154155        async_answer_0(callid, rc);
    155156}
    156157
    157 void remote_usbhc_request_address(device_t *device, void *iface,
     158void remote_usbhc_request_address(ddf_fun_t *fun, void *iface,
    158159    ipc_callid_t callid, ipc_call_t *call)
    159160{
    … …  
    168169
    169170        usb_address_t address;
    170         int rc = usb_iface->request_address(device, speed, &address);
     171        int rc = usb_iface->request_address(fun, speed, &address);
    171172        if (rc != EOK) {
    172173                async_answer_0(callid, rc);
    … …  
    176177}
    177178
    178 void remote_usbhc_bind_address(device_t *device, void *iface,
     179void remote_usbhc_bind_address(ddf_fun_t *fun, void *iface,
    179180    ipc_callid_t callid, ipc_call_t *call)
    180181{
    … …  
    189190        devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call);
    190191
    191         int rc = usb_iface->bind_address(device, address, handle);
     192        int rc = usb_iface->bind_address(fun, address, handle);
    192193
    193194        async_answer_0(callid, rc);
    194195}
    195196
    196 void remote_usbhc_release_address(device_t *device, void *iface,
     197void remote_usbhc_release_address(ddf_fun_t *fun, void *iface,
    197198    ipc_callid_t callid, ipc_call_t *call)
    198199{
    … …  
    206207        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
    207208
    208         int rc = usb_iface->release_address(device, address);
     209        int rc = usb_iface->release_address(fun, address);
    209210
    210211        async_answer_0(callid, rc);
    … …  
    212213
    213214
    214 static void callback_out(device_t *device,
     215static void callback_out(ddf_fun_t *fun,
    215216    int outcome, void *arg)
    216217{
    … …  
    222223}
    223224
    224 static void callback_in(device_t *device,
     225static void callback_in(ddf_fun_t *fun,
    225226    int outcome, size_t actual_size, void *arg)
    226227{
    … …  
    255256 * @param transfer_func Transfer function (might be NULL).
    256257 */
    257 static void remote_usbhc_out_transfer(device_t *device,
     258static void remote_usbhc_out_transfer(ddf_fun_t *fun,
    258259    ipc_callid_t callid, ipc_call_t *call,
    259260    usbhc_iface_transfer_out_t transfer_func)
    … …  
    294295        trans->size = len;
    295296
    296         rc = transfer_func(device, target, max_packet_size,
     297        rc = transfer_func(fun, target, max_packet_size,
    297298            buffer, len,
    298299            callback_out, trans);
    … …  
    311312 * @param transfer_func Transfer function (might be NULL).
    312313 */
    313 static void remote_usbhc_in_transfer(device_t *device,
     314static void remote_usbhc_in_transfer(ddf_fun_t *fun,
    314315    ipc_callid_t callid, ipc_call_t *call,
    315316    usbhc_iface_transfer_in_t transfer_func)
    … …  
    342343        trans->size = len;
    343344
    344         int rc = transfer_func(device, target, max_packet_size,
     345        int rc = transfer_func(fun, target, max_packet_size,
    345346            trans->buffer, len,
    346347            callback_in, trans);
    … …  
    352353}
    353354
    354 void remote_usbhc_interrupt_out(device_t *device, void *iface,
     355void remote_usbhc_interrupt_out(ddf_fun_t *fun, void *iface,
    355356    ipc_callid_t callid, ipc_call_t *call)
    356357{
    … …  
    358359        assert(usb_iface != NULL);
    359360
    360         return remote_usbhc_out_transfer(device, callid, call,
     361        return remote_usbhc_out_transfer(fun, callid, call,
    361362            usb_iface->interrupt_out);
    362363}
    363364
    364 void remote_usbhc_interrupt_in(device_t *device, void *iface,
     365void remote_usbhc_interrupt_in(ddf_fun_t *fun, void *iface,
    365366    ipc_callid_t callid, ipc_call_t *call)
    366367{
    … …  
    368369        assert(usb_iface != NULL);
    369370
    370         return remote_usbhc_in_transfer(device, callid, call,
     371        return remote_usbhc_in_transfer(fun, callid, call,
    371372            usb_iface->interrupt_in);
    372373}
    373374
    374 void remote_usbhc_bulk_out(device_t *device, void *iface,
     375void remote_usbhc_bulk_out(ddf_fun_t *fun, void *iface,
    375376    ipc_callid_t callid, ipc_call_t *call)
    376377{
    … …  
    378379        assert(usb_iface != NULL);
    379380
    380         return remote_usbhc_out_transfer(device, callid, call,
     381        return remote_usbhc_out_transfer(fun, callid, call,
    381382            usb_iface->bulk_out);
    382383}
    383384
    384 void remote_usbhc_bulk_in(device_t *device, void *iface,
     385void remote_usbhc_bulk_in(ddf_fun_t *fun, void *iface,
    385386    ipc_callid_t callid, ipc_call_t *call)
    386387{
    … …  
    388389        assert(usb_iface != NULL);
    389390
    390         return remote_usbhc_in_transfer(device, callid, call,
     391        return remote_usbhc_in_transfer(fun, callid, call,
    391392            usb_iface->bulk_in);
    392393}
    393394
    394 void remote_usbhc_control_write(device_t *device, void *iface,
     395void remote_usbhc_control_write(ddf_fun_t *fun, void *iface,
    395396ipc_callid_t callid, ipc_call_t *call)
    396397{
    … …  
    444445        trans->size = data_buffer_len;
    445446
    446         rc = usb_iface->control_write(device, target, max_packet_size,
     447        rc = usb_iface->control_write(fun, target, max_packet_size,
    447448            setup_packet, setup_packet_len,
    448449            data_buffer, data_buffer_len,
    … …  
    456457
    457458
    458 void remote_usbhc_control_read(device_t *device, void *iface,
     459void remote_usbhc_control_read(ddf_fun_t *fun, void *iface,
    459460ipc_callid_t callid, ipc_call_t *call)
    460461{
    … …  
    509510        }
    510511
    511         rc = usb_iface->control_read(device, target, max_packet_size,
     512        rc = usb_iface->control_read(fun, target, max_packet_size,
    512513            setup_packet, setup_packet_len,
    513514            trans->buffer, trans->size,

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

    rdbe25f1 reb1a2f4  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3334 */
    3435
    35 #ifndef LIBDRV_DRIVER_H_
    36 #define LIBDRV_DRIVER_H_
     36#ifndef DDF_DRIVER_H_
     37#define DDF_DRIVER_H_
    3738
    38 #include <sys/types.h>
    39 #include <kernel/ddi/irq.h>
    40 #include <adt/list.h>
    41 #include <devman.h>
    4239#include <ipc/devman.h>
    4340#include <ipc/dev_iface.h>
    44 #include <assert.h>
    45 #include <ddi.h>
    46 #include <libarch/ddi.h>
    47 #include <fibril_synch.h>
    48 #include <malloc.h>
    4941
    50 #include "dev_iface.h"
     42#include "../dev_iface.h"
    5143
    52 struct device;
    53 typedef struct device device_t;
     44typedef struct ddf_dev ddf_dev_t;
     45typedef struct ddf_fun ddf_fun_t;
    5446
    5547/*
    56  * Device class
     48 * Device
    5749 */
    5850
    5951/** Devices operations */
    60 typedef struct device_ops {
     52typedef struct ddf_dev_ops {
    6153        /**
    6254         * Optional callback function called when a client is connecting to the
    6355         * device.
    6456         */
    65         int (*open)(device_t *);
     57        int (*open)(ddf_fun_t *);
    6658       
    6759        /**
    … …  
    6961         * the device.
    7062         */
    71         void (*close)(device_t *);
     63        void (*close)(ddf_fun_t *);
    7264       
    7365        /** The table of standard interfaces implemented by the device. */
    … …  
    8072         */
    8173        remote_handler_t *default_handler;
    82 } device_ops_t;
    83 
    84 
    85 /*
    86  * Device
    87  */
     74} ddf_dev_ops_t;
    8875
    8976/** Device structure */
    90 struct device {
     77struct ddf_dev {
    9178        /**
    9279         * Globally unique device identifier (assigned to the device by the
    … …  
    10188        int parent_phone;
    10289       
    103         /** Parent device if handled by this driver, NULL otherwise */
    104         device_t *parent;
    10590        /** Device name */
    10691        const char *name;
    107         /** List of device ids for device-to-driver matching */
    108         match_id_list_t match_ids;
     92       
    10993        /** Driver-specific data associated with this device */
    11094        void *driver_data;
    111         /** The implementation of operations provided by this device */
    112         device_ops_t *ops;
    11395       
    11496        /** Link in the list of devices handled by the driver */
     97        link_t link;
     98};
     99
     100/** Function structure */
     101struct ddf_fun {
     102        /** True if bound to the device manager */
     103        bool bound;
     104        /** Function indentifier (asigned by device manager) */
     105        devman_handle_t handle;
     106       
     107        /** Device which this function belogs to */
     108        ddf_dev_t *dev;
     109       
     110        /** Function type */
     111        fun_type_t ftype;
     112        /** Function name */
     113        const char *name;
     114        /** List of device ids for driver matching */
     115        match_id_list_t match_ids;
     116        /** Driver-specific data associated with this function */
     117        void *driver_data;
     118        /** Implementation of operations provided by this function */
     119        ddf_dev_ops_t *ops;
     120       
     121        /** Link in the list of functions handled by the driver */
    115122        link_t link;
    116123};
    … …  
    123130typedef struct driver_ops {
    124131        /** Callback method for passing a new device to the device driver */
    125         int (*add_device)(device_t *dev);
     132        int (*add_device)(ddf_dev_t *dev);
    126133        /* TODO: add other generic driver operations */
    127134} driver_ops_t;
    … …  
    135142} driver_t;
    136143
    137 int driver_main(driver_t *);
     144extern int ddf_driver_main(driver_t *);
    138145
    139 /** Create new device structure.
    140  *
    141  * @return              The device structure.
    142  */
    143 extern device_t *create_device(void);
    144 extern void delete_device(device_t *);
    145 extern void *device_get_ops(device_t *, dev_inferface_idx_t);
     146extern ddf_fun_t *ddf_fun_create(ddf_dev_t *, fun_type_t, const char *);
     147extern void ddf_fun_destroy(ddf_fun_t *);
     148extern int ddf_fun_bind(ddf_fun_t *);
     149extern int ddf_fun_add_match_id(ddf_fun_t *, const char *, int);
    146150
    147 extern int child_device_register(device_t *, device_t *);
    148 extern int child_device_register_wrapper(device_t *, const char *, const char *,
    149     int, devman_handle_t *);
    150 
    151 /*
    152  * Interrupts
    153  */
    154 
    155 typedef void interrupt_handler_t(device_t *, ipc_callid_t, ipc_call_t *);
    156 
    157 typedef struct interrupt_context {
    158         int id;
    159         device_t *dev;
    160         int irq;
    161         interrupt_handler_t *handler;
    162         link_t link;
    163 } interrupt_context_t;
    164 
    165 typedef struct interrupt_context_list {
    166         int curr_id;
    167         link_t contexts;
    168         fibril_mutex_t mutex;
    169 } interrupt_context_list_t;
    170 
    171 extern interrupt_context_t *create_interrupt_context(void);
    172 extern void delete_interrupt_context(interrupt_context_t *);
    173 extern void init_interrupt_context_list(interrupt_context_list_t *);
    174 extern void add_interrupt_context(interrupt_context_list_t *,
    175     interrupt_context_t *);
    176 extern void remove_interrupt_context(interrupt_context_list_t *,
    177     interrupt_context_t *);
    178 extern interrupt_context_t *find_interrupt_context_by_id(
    179     interrupt_context_list_t *, int);
    180 extern interrupt_context_t *find_interrupt_context(
    181     interrupt_context_list_t *, device_t *, int);
    182 
    183 extern int register_interrupt_handler(device_t *, int, interrupt_handler_t *,
    184     irq_code_t *);
    185 extern int unregister_interrupt_handler(device_t *, int);
    186 
    187 extern remote_handler_t *device_get_default_handler(device_t *);
    188 extern int add_device_to_class(device_t *, const char *);
     151extern int ddf_fun_add_to_class(ddf_fun_t *, const char *);
    189152
    190153#endif

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

    rdbe25f1 reb1a2f4  
    4343 */
    4444
    45 struct device;
     45struct ddf_fun;
    4646
    4747/*
    … …  
    4949 * devices driver.
    5050 */
    51 typedef void remote_iface_func_t(struct device *, void *, ipc_callid_t,
     51typedef void remote_iface_func_t(struct ddf_fun *, void *, ipc_callid_t,
    5252    ipc_call_t *);
    5353typedef remote_iface_func_t *remote_iface_func_ptr_t;
    54 typedef void remote_handler_t(struct device *, ipc_callid_t, ipc_call_t *);
     54typedef void remote_handler_t(struct ddf_fun *, ipc_callid_t, ipc_call_t *);
    5555
    5656typedef struct {

  • uspace/lib/drv/include/ops/char_dev.h

    rdbe25f1 reb1a2f4  
    3636#define LIBDRV_OPS_CHAR_DEV_H_
    3737
    38 #include "../driver.h"
     38#include "../ddf/driver.h"
    3939
    4040typedef struct {
    41         int (*read)(device_t *, char *, size_t);
    42         int (*write)(device_t *, char *, size_t);
     41        int (*read)(ddf_fun_t *, char *, size_t);
     42        int (*write)(ddf_fun_t *, char *, size_t);
    4343} char_dev_ops_t;
    4444

  • uspace/lib/drv/include/ops/hw_res.h

    rdbe25f1 reb1a2f4  
    3939#include <sys/types.h>
    4040
    41 #include "../driver.h"
     41#include "../ddf/driver.h"
    4242
    4343typedef struct {
    44          hw_resource_list_t *(*get_resource_list)(device_t *);
    45          bool (*enable_interrupt)(device_t *);
     44         hw_resource_list_t *(*get_resource_list)(ddf_fun_t *);
     45         bool (*enable_interrupt)(ddf_fun_t *);
    4646} hw_res_ops_t;
    4747

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

    rdbe25f1 reb1a2f4  
    3838#define LIBDRV_USB_IFACE_H_
    3939
    40 #include "driver.h"
     40#include "ddf/driver.h"
    4141#include <usb/usb.h>
    4242typedef enum {
    … …  
    7575/** USB device communication interface. */
    7676typedef struct {
    77         int (*get_address)(device_t *, devman_handle_t, usb_address_t *);
    78         int (*get_interface)(device_t *, devman_handle_t, int *);
    79         int (*get_hc_handle)(device_t *, devman_handle_t *);
     77        int (*get_address)(ddf_fun_t *, devman_handle_t, usb_address_t *);
     78        int (*get_interface)(ddf_fun_t *, devman_handle_t, int *);
     79        int (*get_hc_handle)(ddf_fun_t *, devman_handle_t *);
    8080} usb_iface_t;
    8181

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

    rdbe25f1 reb1a2f4  
    3838#define LIBDRV_USBHC_IFACE_H_
    3939
    40 #include "driver.h"
     40#include "ddf/driver.h"
    4141#include <usb/usb.h>
    4242#include <bool.h>
    … …  
    171171
    172172/** Callback for outgoing transfer. */
    173 typedef void (*usbhc_iface_transfer_out_callback_t)(device_t *,
     173typedef void (*usbhc_iface_transfer_out_callback_t)(ddf_fun_t *,
    174174    int, void *);
    175175
    176176/** Callback for incoming transfer. */
    177 typedef void (*usbhc_iface_transfer_in_callback_t)(device_t *,
     177typedef void (*usbhc_iface_transfer_in_callback_t)(ddf_fun_t *,
    178178    int, size_t, void *);
    179179
    180180
    181181/** Out transfer processing function prototype. */
    182 typedef int (*usbhc_iface_transfer_out_t)(device_t *, usb_target_t, size_t,
     182typedef int (*usbhc_iface_transfer_out_t)(ddf_fun_t *, usb_target_t, size_t,
    183183    void *, size_t,
    184184    usbhc_iface_transfer_out_callback_t, void *);
    … …  
    188188
    189189/** In transfer processing function prototype. */
    190 typedef int (*usbhc_iface_transfer_in_t)(device_t *, usb_target_t, size_t,
     190typedef int (*usbhc_iface_transfer_in_t)(ddf_fun_t *, usb_target_t, size_t,
    191191    void *, size_t,
    192192    usbhc_iface_transfer_in_callback_t, void *);
    … …  
    194194/** USB host controller communication interface. */
    195195typedef struct {
    196         int (*reserve_default_address)(device_t *, usb_speed_t);
    197         int (*release_default_address)(device_t *);
    198         int (*request_address)(device_t *, usb_speed_t, usb_address_t *);
    199         int (*bind_address)(device_t *, usb_address_t, devman_handle_t);
    200         int (*release_address)(device_t *, usb_address_t);
     196        int (*reserve_default_address)(ddf_fun_t *, usb_speed_t);
     197        int (*release_default_address)(ddf_fun_t *);
     198        int (*request_address)(ddf_fun_t *, usb_speed_t, usb_address_t *);
     199        int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);
     200        int (*release_address)(ddf_fun_t *, usb_address_t);
    201201
    202202        usbhc_iface_transfer_out_t interrupt_out;
    … …  
    206206        usbhc_iface_transfer_in_t bulk_in;
    207207
    208         int (*control_write)(device_t *, usb_target_t,
     208        int (*control_write)(ddf_fun_t *, usb_target_t,
    209209            size_t,
    210210            void *, size_t, void *, size_t,
    211211            usbhc_iface_transfer_out_callback_t, void *);
    212212
    213         int (*control_read)(device_t *, usb_target_t,
     213        int (*control_read)(ddf_fun_t *, usb_target_t,
    214214            size_t,
    215215            void *, size_t, void *, size_t,
Note: See TracChangeset for help on using the changeset viewer.