Changeset 83a2f43 in mainline


Ignore:
Timestamp:
2011-02-15T19:43:50Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
af6b5157
Parents:
34588a80
Message:

Rename bunch of stuff so that it starts with 'ddf_'.

Location:
uspace
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/isa/isa.c

    r34588a80 r83a2f43  
    6868
    6969typedef struct isa_fun {
    70         function_t *fnode;
     70        ddf_fun_t *fnode;
    7171        hw_resource_list_t hw_resources;
    7272} isa_fun_t;
    7373
    74 static hw_resource_list_t *isa_get_fun_resources(function_t *fnode)
     74static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
    7575{
    7676        isa_fun_t *fun = ISA_FUN(fnode);
     
    8080}
    8181
    82 static bool isa_enable_fun_interrupt(function_t *fnode)
     82static bool isa_enable_fun_interrupt(ddf_fun_t *fnode)
    8383{
    8484        // TODO
     
    9292};
    9393
    94 static device_ops_t isa_fun_ops;
    95 
    96 static int isa_add_device(device_t *dev);
     94static ddf_dev_ops_t isa_fun_ops;
     95
     96static int isa_add_device(ddf_dev_t *dev);
    9797
    9898/** The isa device driver's standard operations */
     
    107107};
    108108
    109 static isa_fun_t *isa_fun_create(device_t *dev, const char *name)
     109static isa_fun_t *isa_fun_create(ddf_dev_t *dev, const char *name)
    110110{
    111111        isa_fun_t *fun = calloc(1, sizeof(isa_fun_t));
     
    113113                return NULL;
    114114
    115         function_t *fnode = ddf_fun_create(dev, fun_inner, name);
     115        ddf_fun_t *fnode = ddf_fun_create(dev, fun_inner, name);
    116116        if (fnode == NULL) {
    117117                free(fun);
     
    388388}
    389389
    390 static char *isa_fun_read_info(char *fun_conf, device_t *dev)
     390static char *isa_fun_read_info(char *fun_conf, ddf_dev_t *dev)
    391391{
    392392        char *line;
     
    447447}
    448448
    449 static void fun_conf_parse(char *conf, device_t *dev)
     449static void fun_conf_parse(char *conf, ddf_dev_t *dev)
    450450{
    451451        while (conf != NULL && *conf != '\0') {
     
    454454}
    455455
    456 static void isa_functions_add(device_t *dev)
     456static void isa_functions_add(ddf_dev_t *dev)
    457457{
    458458        char *fun_conf;
     
    465465}
    466466
    467 static int isa_add_device(device_t *dev)
     467static int isa_add_device(ddf_dev_t *dev)
    468468{
    469469        printf(NAME ": isa_add_device, device handle = %d\n",
     
    473473        printf(NAME ": adding a 'ctl' function\n");
    474474
    475         function_t *ctl = ddf_fun_create(dev, fun_exposed, "ctl");
     475        ddf_fun_t *ctl = ddf_fun_create(dev, fun_exposed, "ctl");
    476476        if (ctl == NULL) {
    477477                printf(NAME ": Error creating control function.\n");
     
    500500        printf(NAME ": HelenOS ISA bus driver\n");
    501501        isa_init();
    502         return driver_main(&isa_driver);
     502        return ddf_driver_main(&isa_driver);
    503503}
    504504
  • uspace/drv/ns8250/ns8250.c

    r34588a80 r83a2f43  
    9494typedef struct ns8250 {
    9595        /** DDF device node */
    96         device_t *dev;
     96        ddf_dev_t *dev;
    9797        /** DDF function node */
    98         function_t *fun;
     98        ddf_fun_t *fun;
    9999        /** Is there any client conntected to the device? */
    100100        bool client_connected;
     
    189189 *                      error number otherwise.
    190190 */
    191 static int ns8250_read(function_t *fun, char *buf, size_t count)
     191static int ns8250_read(ddf_fun_t *fun, char *buf, size_t count)
    192192{
    193193        ns8250_t *ns = NS8250(fun);
     
    223223 * @return              Zero on success
    224224 */
    225 static int ns8250_write(function_t *fun, char *buf, size_t count)
     225static int ns8250_write(ddf_fun_t *fun, char *buf, size_t count)
    226226{
    227227        ns8250_t *ns = NS8250(fun);
     
    234234}
    235235
    236 static device_ops_t ns8250_dev_ops;
     236static ddf_dev_ops_t ns8250_dev_ops;
    237237
    238238/** The character interface's callbacks. */
     
    242242};
    243243
    244 static int ns8250_add_device(device_t *dev);
     244static int ns8250_add_device(ddf_dev_t *dev);
    245245
    246246/** The serial port device driver's standard operations. */
     
    675675 * @param dev           The serial port device.
    676676 */
    677 static inline void ns8250_interrupt_handler(device_t *dev, ipc_callid_t iid,
     677static inline void ns8250_interrupt_handler(ddf_dev_t *dev, ipc_callid_t iid,
    678678    ipc_call_t *icall)
    679679{
     
    706706 * @param dev           The serial port device.
    707707 */
    708 static int ns8250_add_device(device_t *dev)
     708static int ns8250_add_device(ddf_dev_t *dev)
    709709{
    710710        ns8250_t *ns = NULL;
    711         function_t *fun = NULL;
     711        ddf_fun_t *fun = NULL;
    712712        bool need_cleanup = false;
    713713        int rc;
     
    777777        ns->fun = fun;
    778778       
    779         add_function_to_class(fun, "serial");
     779        ddf_fun_add_to_class(fun, "serial");
    780780       
    781781        printf(NAME ": the %s device has been successfully initialized.\n",
     
    800800 * @param dev           The device.
    801801 */
    802 static int ns8250_open(function_t *fun)
     802static int ns8250_open(ddf_fun_t *fun)
    803803{
    804804        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
     
    824824 * @param dev           The device.
    825825 */
    826 static void ns8250_close(function_t *fun)
     826static void ns8250_close(ddf_fun_t *fun)
    827827{
    828828        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
     
    848848 */
    849849static void
    850 ns8250_get_props(device_t *dev, unsigned int *baud_rate, unsigned int *parity,
     850ns8250_get_props(ddf_dev_t *dev, unsigned int *baud_rate, unsigned int *parity,
    851851    unsigned int *word_length, unsigned int* stop_bits)
    852852{
     
    875875 * @param stop_bits     The number of stop bits to be used.
    876876 */
    877 static int ns8250_set_props(device_t *dev, unsigned int baud_rate,
     877static int ns8250_set_props(ddf_dev_t *dev, unsigned int baud_rate,
    878878    unsigned int parity, unsigned int word_length, unsigned int stop_bits)
    879879{
     
    902902 * Configure the parameters of the serial communication.
    903903 */
    904 static void ns8250_default_handler(function_t *fun, ipc_callid_t callid,
     904static void ns8250_default_handler(ddf_fun_t *fun, ipc_callid_t callid,
    905905    ipc_call_t *call)
    906906{
     
    950950        printf(NAME ": HelenOS serial port driver\n");
    951951        ns8250_init();
    952         return driver_main(&ns8250_driver);
     952        return ddf_driver_main(&ns8250_driver);
    953953}
    954954
  • uspace/drv/pciintel/pci.c

    r34588a80 r83a2f43  
    7272#define PCI_BUS_FROM_FUN(fun) ((fun)->busptr)
    7373
    74 static hw_resource_list_t *pciintel_get_resources(function_t *fnode)
     74static hw_resource_list_t *pciintel_get_resources(ddf_fun_t *fnode)
    7575{
    7676        pci_fun_t *fun = PCI_FUN(fnode);
     
    8181}
    8282
    83 static bool pciintel_enable_interrupt(function_t *fnode)
     83static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
    8484{
    8585        /* TODO */
     
    9393};
    9494
    95 static device_ops_t pci_fun_ops;
    96 
    97 static int pci_add_device(device_t *);
     95static ddf_dev_ops_t pci_fun_ops;
     96
     97static int pci_add_device(ddf_dev_t *);
    9898
    9999/** PCI bus driver standard operations */
     
    367367void pci_bus_scan(pci_bus_t *bus, int bus_num)
    368368{
    369         function_t *fnode;
     369        ddf_fun_t *fnode;
    370370        pci_fun_t *fun;
    371371       
     
    459459}
    460460
    461 static int pci_add_device(device_t *dnode)
     461static int pci_add_device(ddf_dev_t *dnode)
    462462{
    463463        pci_bus_t *bus = NULL;
    464         function_t *ctl = NULL;
     464        ddf_fun_t *ctl = NULL;
    465465        bool got_res = false;
    466466        int rc;
     
    633633        printf(NAME ": HelenOS pci bus driver (intel method 1).\n");
    634634        pciintel_init();
    635         return driver_main(&pci_driver);
     635        return ddf_driver_main(&pci_driver);
    636636}
    637637
  • uspace/drv/pciintel/pci.h

    r34588a80 r83a2f43  
    4747typedef struct pciintel_bus {
    4848        /** DDF device node */
    49         device_t *dnode;
     49        ddf_dev_t *dnode;
    5050        uint32_t conf_io_addr;
    5151        void *conf_data_port;
     
    5656typedef struct pci_fun_data {
    5757        pci_bus_t *busptr;
    58         function_t *fnode;
     58        ddf_fun_t *fnode;
    5959
    6060        int bus;
  • uspace/drv/root/root.c

    r34588a80 r83a2f43  
    6565#define VIRTUAL_FUN_MATCH_SCORE 100
    6666
    67 static int root_add_device(device_t *dev);
     67static int root_add_device(ddf_dev_t *dev);
    6868
    6969/** The root device driver's standard operations. */
     
    8383 * @return      EOK on success or negative error code
    8484 */
    85 static int add_virtual_root_fun(device_t *dev)
     85static int add_virtual_root_fun(ddf_dev_t *dev)
    8686{
    8787        const char *name = VIRTUAL_FUN_NAME;
    88         function_t *fun;
     88        ddf_fun_t *fun;
    8989        int rc;
    9090
     
    123123 * @return      EOK on success or negative error code
    124124 */
    125 static int add_platform_fun(device_t *dev)
     125static int add_platform_fun(ddf_dev_t *dev)
    126126{
    127127        char *match_id;
     
    130130
    131131        const char *name = PLATFORM_FUN_NAME;
    132         function_t *fun;
     132        ddf_fun_t *fun;
    133133        int rc;
    134134
     
    189189 *                      of HW and pseudo devices).
    190190 */
    191 static int root_add_device(device_t *dev)
     191static int root_add_device(ddf_dev_t *dev)
    192192{
    193193        printf(NAME ": root_add_device, device handle=%" PRIun "\n",
     
    212212{
    213213        printf(NAME ": HelenOS root device driver\n");
    214         return driver_main(&root_driver);
     214        return ddf_driver_main(&root_driver);
    215215}
    216216
  • uspace/drv/rootpc/rootpc.c

    r34588a80 r83a2f43  
    6262} rootpc_fun_t;
    6363
    64 static int rootpc_add_device(device_t *dev);
     64static int rootpc_add_device(ddf_dev_t *dev);
    6565static void root_pc_init(void);
    6666
     
    9292};
    9393
    94 static hw_resource_list_t *rootpc_get_resources(function_t *fnode)
     94static hw_resource_list_t *rootpc_get_resources(ddf_fun_t *fnode)
    9595{
    9696        rootpc_fun_t *fun = ROOTPC_FUN(fnode);
     
    100100}
    101101
    102 static bool rootpc_enable_interrupt(function_t *fun)
     102static bool rootpc_enable_interrupt(ddf_fun_t *fun)
    103103{
    104104        /* TODO */
     
    113113
    114114/* Initialized in root_pc_init() function. */
    115 static device_ops_t rootpc_fun_ops;
     115static ddf_dev_ops_t rootpc_fun_ops;
    116116
    117117static bool
    118 rootpc_add_fun(device_t *dev, const char *name, const char *str_match_id,
     118rootpc_add_fun(ddf_dev_t *dev, const char *name, const char *str_match_id,
    119119    rootpc_fun_t *fun)
    120120{
    121121        printf(NAME ": adding new function '%s'.\n", name);
    122122       
    123         function_t *fnode = NULL;
     123        ddf_fun_t *fnode = NULL;
    124124        match_id_t *match_id = NULL;
    125125       
     
    164164}
    165165
    166 static bool rootpc_add_functions(device_t *dev)
     166static bool rootpc_add_functions(ddf_dev_t *dev)
    167167{
    168168        return rootpc_add_fun(dev, "pci0", "intel_pci", &pci_data);
     
    175175 * @return              Zero on success, negative error number otherwise.
    176176 */
    177 static int rootpc_add_device(device_t *dev)
     177static int rootpc_add_device(ddf_dev_t *dev)
    178178{
    179179        printf(NAME ": rootpc_add_device, device handle = %d\n",
     
    197197        printf(NAME ": HelenOS PC platform driver\n");
    198198        root_pc_init();
    199         return driver_main(&rootpc_driver);
     199        return ddf_driver_main(&rootpc_driver);
    200200}
    201201
  • uspace/drv/rootvirt/rootvirt.c

    r34588a80 r83a2f43  
    6161};
    6262
    63 static int rootvirt_add_device(device_t *dev);
     63static int rootvirt_add_device(ddf_dev_t *dev);
    6464
    6565static driver_ops_t rootvirt_ops = {
     
    7878 * @return              EOK on success or negative error code.
    7979 */
    80 static int rootvirt_add_fun(device_t *vdev, virtual_function_t *vfun)
     80static int rootvirt_add_fun(ddf_dev_t *vdev, virtual_function_t *vfun)
    8181{
    82         function_t *fun;
     82        ddf_fun_t *fun;
    8383        int rc;
    8484
     
    112112}
    113113
    114 static int rootvirt_add_device(device_t *dev)
     114static int rootvirt_add_device(ddf_dev_t *dev)
    115115{
    116116        static int instances = 0;
     
    142142{
    143143        printf(NAME ": HelenOS virtual devices root driver\n");
    144         return driver_main(&rootvirt_driver);
     144        return ddf_driver_main(&rootvirt_driver);
    145145}
    146146
  • uspace/drv/test1/char.c

    r34588a80 r83a2f43  
    3737#include "test1.h"
    3838
    39 static int impl_char_read(function_t *fun, char *buf, size_t count) {
     39static int impl_char_read(ddf_fun_t *fun, char *buf, size_t count) {
    4040        memset(buf, 0, count);
    4141        return count;
    4242}
    4343
    44 static int imp_char_write(function_t *fun, char *buf, size_t count) {
     44static int imp_char_write(ddf_fun_t *fun, char *buf, size_t count) {
    4545        return count;
    4646}
     
    5151};
    5252
    53 device_ops_t char_device_ops = {
     53ddf_dev_ops_t char_device_ops = {
    5454        .interfaces[CHAR_DEV_IFACE] = &char_dev_ops
    5555};
  • uspace/drv/test1/test1.c

    r34588a80 r83a2f43  
    3636#include "test1.h"
    3737
    38 static int test1_add_device(device_t *dev);
     38static int test1_add_device(ddf_dev_t *dev);
    3939
    4040static driver_ops_t driver_ops = {
     
    5555 * @param score Device match score.
    5656 */
    57 static int register_fun_verbose(device_t *parent, const char *message,
     57static int register_fun_verbose(ddf_dev_t *parent, const char *message,
    5858    const char *name, const char *match_id, int match_score)
    5959{
    60         function_t *fun;
     60        ddf_fun_t *fun;
    6161        int rc;
    6262
     
    105105 * @return Error code reporting success of the operation.
    106106 */
    107 static int test1_add_device(device_t *dev)
     107static int test1_add_device(ddf_dev_t *dev)
    108108{
    109         function_t *fun_a;
     109        ddf_fun_t *fun_a;
    110110        int rc;
    111111
     
    125125        }
    126126
    127         add_function_to_class(fun_a, "virtual");
     127        ddf_fun_add_to_class(fun_a, "virtual");
    128128
    129129        if (str_cmp(dev->name, "null") == 0) {
    130130                fun_a->ops = &char_device_ops;
    131                 add_function_to_class(fun_a, "virt-null");
     131                ddf_fun_add_to_class(fun_a, "virt-null");
    132132        } else if (str_cmp(dev->name, "test1") == 0) {
    133133                (void) register_fun_verbose(dev, "cloning myself ;-)", "clone",
     
    146146{
    147147        printf(NAME ": HelenOS test1 virtual device driver\n");
    148         return driver_main(&test1_driver);
     148        return ddf_driver_main(&test1_driver);
    149149}
    150150
  • uspace/drv/test1/test1.h

    r34588a80 r83a2f43  
    3636#define NAME "test1"
    3737
    38 extern device_ops_t char_device_ops;
     38extern ddf_dev_ops_t char_device_ops;
    3939
    4040#endif
  • uspace/drv/test2/test2.c

    r34588a80 r83a2f43  
    3838#define NAME "test2"
    3939
    40 static int test2_add_device(device_t *dev);
     40static int test2_add_device(ddf_dev_t *dev);
    4141
    4242static driver_ops_t driver_ops = {
     
    5757 * @param score Device match score.
    5858 */
    59 static int register_fun_verbose(device_t *parent, const char *message,
     59static int register_fun_verbose(ddf_dev_t *parent, const char *message,
    6060    const char *name, const char *match_id, int match_score)
    6161{
    62         function_t *fun;
     62        ddf_fun_t *fun;
    6363        int rc;
    6464
     
    9292/** Add child devices after some sleep.
    9393 *
    94  * @param arg Parent device structure (device_t *).
     94 * @param arg Parent device structure (ddf_dev_t *).
    9595 * @return Always EOK.
    9696 */
    9797static int postponed_birth(void *arg)
    9898{
    99         device_t *dev = (device_t *) arg;
    100         function_t *fun_a;
     99        ddf_dev_t *dev = (ddf_dev_t *) arg;
     100        ddf_fun_t *fun_a;
    101101        int rc;
    102102
     
    120120        }
    121121
    122         add_function_to_class(fun_a, "virtual");
     122        ddf_fun_add_to_class(fun_a, "virtual");
    123123
    124124        return EOK;
    125125}
    126126
    127 static int test2_add_device(device_t *dev)
     127static int test2_add_device(ddf_dev_t *dev)
    128128{
    129129        printf(NAME ": test2_add_device(name=\"%s\", handle=%d)\n",
     
    148148{
    149149        printf(NAME ": HelenOS test2 virtual device driver\n");
    150         return driver_main(&test2_driver);
     150        return ddf_driver_main(&test2_driver);
    151151}
    152152
  • uspace/lib/drv/generic/driver.c

    r34588a80 r83a2f43  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    7677};
    7778
    78 static device_t *create_device(void);
    79 static void delete_device(device_t *);
     79static ddf_dev_t *create_device(void);
     80static void delete_device(ddf_dev_t *);
    8081
    8182static void driver_irq_handler(ipc_callid_t iid, ipc_call_t *icall)
     
    152153
    153154interrupt_context_t *
    154 find_interrupt_context(interrupt_context_list_t *list, device_t *dev, int irq)
     155find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq)
    155156{
    156157        fibril_mutex_lock(&list->mutex);
     
    174175
    175176int
    176 register_interrupt_handler(device_t *dev, int irq, interrupt_handler_t *handler,
     177register_interrupt_handler(ddf_dev_t *dev, int irq, interrupt_handler_t *handler,
    177178    irq_code_t *pseudocode)
    178179{
     
    197198}
    198199
    199 int unregister_interrupt_handler(device_t *dev, int irq)
     200int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
    200201{
    201202        interrupt_context_t *ctx = find_interrupt_context(&interrupt_contexts,
     
    211212}
    212213
    213 static void add_to_functions_list(function_t *fun)
     214static void add_to_functions_list(ddf_fun_t *fun)
    214215{
    215216        fibril_mutex_lock(&functions_mutex);
     
    218219}
    219220
    220 static void remove_from_functions_list(function_t *fun)
     221static void remove_from_functions_list(ddf_fun_t *fun)
    221222{
    222223        fibril_mutex_lock(&functions_mutex);
     
    225226}
    226227
    227 static function_t *driver_get_function(link_t *functions, devman_handle_t handle)
    228 {
    229         function_t *fun = NULL;
     228static ddf_fun_t *driver_get_function(link_t *functions, devman_handle_t handle)
     229{
     230        ddf_fun_t *fun = NULL;
    230231        printf("driver_get_function handle=%" PRIun "\n", handle);
    231232       
     
    234235       
    235236        while (link != functions) {
    236                 fun = list_get_instance(link, function_t, link);
     237                fun = list_get_instance(link, ddf_fun_t, link);
    237238                printf(" - fun handle %" PRIun "\n", fun->handle);
    238239                if (fun->handle == handle) {
     
    257258        devman_handle_t parent_fun_handle = IPC_GET_ARG2(*icall);
    258259       
    259         device_t *dev = create_device();
     260        ddf_dev_t *dev = create_device();
    260261        dev->handle = dev_handle;
    261262
     
    318319         */
    319320        devman_handle_t handle = IPC_GET_ARG2(*icall);
    320         function_t *fun = driver_get_function(&functions, handle);
     321        ddf_fun_t *fun = driver_get_function(&functions, handle);
    321322
    322323        if (fun == NULL) {
     
    461462 * @return              The device structure.
    462463 */
    463 static device_t *create_device(void)
    464 {
    465         device_t *dev;
    466 
    467         dev = malloc(sizeof(device_t));
     464static ddf_dev_t *create_device(void)
     465{
     466        ddf_dev_t *dev;
     467
     468        dev = malloc(sizeof(ddf_dev_t));
    468469        if (dev == NULL)
    469470                return NULL;
    470471
    471         memset(dev, 0, sizeof(device_t));
     472        memset(dev, 0, sizeof(ddf_dev_t));
    472473        return dev;
    473474}
     
    477478 * @return              The device structure.
    478479 */
    479 static function_t *create_function(void)
    480 {
    481         function_t *fun;
    482 
    483         fun = calloc(1, sizeof(function_t));
     480static ddf_fun_t *create_function(void)
     481{
     482        ddf_fun_t *fun;
     483
     484        fun = calloc(1, sizeof(ddf_fun_t));
    484485        if (fun == NULL)
    485486                return NULL;
     
    495496 * @param dev           The device structure.
    496497 */
    497 static void delete_device(device_t *dev)
     498static void delete_device(ddf_dev_t *dev)
    498499{
    499500        free(dev);
     
    504505 * @param dev           The device structure.
    505506 */
    506 static void delete_function(function_t *fun)
     507static void delete_function(ddf_fun_t *fun)
    507508{
    508509        clean_match_ids(&fun->match_ids);
     
    535536 * @return              New function or @c NULL if memory is not available
    536537 */
    537 function_t *ddf_fun_create(device_t *dev, fun_type_t ftype, const char *name)
    538 {
    539         function_t *fun;
     538ddf_fun_t *ddf_fun_create(ddf_dev_t *dev, fun_type_t ftype, const char *name)
     539{
     540        ddf_fun_t *fun;
    540541
    541542        fun = create_function();
     
    563564 * @param fun           Function to destroy
    564565 */
    565 void ddf_fun_destroy(function_t *fun)
     566void ddf_fun_destroy(ddf_fun_t *fun)
    566567{
    567568        assert(fun->bound == false);
     
    569570}
    570571
    571 void *function_get_ops(function_t *fun, dev_inferface_idx_t idx)
     572void *function_get_ops(ddf_fun_t *fun, dev_inferface_idx_t idx)
    572573{
    573574        assert(is_valid_iface_idx(idx));
     
    589590 * @return              EOK on success or negative error code
    590591 */
    591 int ddf_fun_bind(function_t *fun)
     592int ddf_fun_bind(ddf_fun_t *fun)
    592593{
    593594        assert(fun->name != NULL);
     
    617618 * @return                      EOK on success, ENOMEM if out of memory.
    618619 */
    619 int ddf_fun_add_match_id(function_t *fun, const char *match_id_str,
     620int ddf_fun_add_match_id(ddf_fun_t *fun, const char *match_id_str,
    620621    int match_score)
    621622{
     
    637638
    638639/** Get default handler for client requests */
    639 remote_handler_t *function_get_default_handler(function_t *fun)
     640remote_handler_t *function_get_default_handler(ddf_fun_t *fun)
    640641{
    641642        if (fun->ops == NULL)
     
    648649 * Must only be called when the function is bound.
    649650 */
    650 int add_function_to_class(function_t *fun, const char *class_name)
     651int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name)
    651652{
    652653        assert(fun->bound == true);
     
    656657}
    657658
    658 int driver_main(driver_t *drv)
     659int ddf_driver_main(driver_t *drv)
    659660{
    660661        /*
  • uspace/lib/drv/generic/remote_char_dev.c

    r34588a80 r83a2f43  
    4141#define MAX_CHAR_RW_COUNT 256
    4242
    43 static void remote_char_read(function_t *, void *, ipc_callid_t, ipc_call_t *);
    44 static void remote_char_write(function_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. */
     
    7171 */
    7272static void
    73 remote_char_read(function_t *fun, 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{
     
    118118 */
    119119static void
    120 remote_char_write(function_t *fun, 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{
  • uspace/lib/drv/generic/remote_hw_res.c

    r34588a80 r83a2f43  
    3939#include "driver.h"
    4040
    41 static void remote_hw_res_get_resource_list(function_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(function_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(function_t *fun, 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{
     
    6868}
    6969
    70 static void remote_hw_res_get_resource_list(function_t *fun, 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{
  • uspace/lib/drv/include/dev_iface.h

    r34588a80 r83a2f43  
    4343 */
    4444
    45 struct function;
     45struct ddf_fun;
    4646
    4747/*
     
    4949 * devices driver.
    5050 */
    51 typedef void remote_iface_func_t(struct function *, 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 function *, 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/driver.h

    r34588a80 r83a2f43  
    4949#include "dev_iface.h"
    5050
    51 struct device;
    52 typedef struct device device_t;
    53 
    54 struct function;
    55 typedef struct function function_t;
     51typedef struct ddf_dev ddf_dev_t;
     52typedef struct ddf_fun ddf_fun_t;
    5653
    5754/*
     
    6057
    6158/** Devices operations */
    62 typedef struct device_ops {
     59typedef struct ddf_dev_ops {
    6360        /**
    6461         * Optional callback function called when a client is connecting to the
    6562         * device.
    6663         */
    67         int (*open)(function_t *);
     64        int (*open)(ddf_fun_t *);
    6865       
    6966        /**
     
    7168         * the device.
    7269         */
    73         void (*close)(function_t *);
     70        void (*close)(ddf_fun_t *);
    7471       
    7572        /** The table of standard interfaces implemented by the device. */
     
    8279         */
    8380        remote_handler_t *default_handler;
    84 } device_ops_t;
    85 
     81} ddf_dev_ops_t;
    8682
    8783/*
     
    9086
    9187/** Device structure */
    92 struct device {
     88struct ddf_dev {
    9389        /**
    9490         * Globally unique device identifier (assigned to the device by the
     
    114110
    115111/** Function structure */
    116 struct function {
     112struct ddf_fun {
    117113        /** True if bound to the device manager */
    118114        bool bound;
     
    121117       
    122118        /** Device which this function belogs to */
    123         device_t *dev;
     119        ddf_dev_t *dev;
    124120       
    125121        /** Function type */
     
    132128        void *driver_data;
    133129        /** Implementation of operations provided by this function */
    134         device_ops_t *ops;
     130        ddf_dev_ops_t *ops;
    135131       
    136132        /** Link in the list of functions handled by the driver */
     
    145141typedef struct driver_ops {
    146142        /** Callback method for passing a new device to the device driver */
    147         int (*add_device)(device_t *dev);
     143        int (*add_device)(ddf_dev_t *dev);
    148144        /* TODO: add other generic driver operations */
    149145} driver_ops_t;
     
    157153} driver_t;
    158154
    159 int driver_main(driver_t *);
    160 
    161 extern function_t *ddf_fun_create(device_t *, fun_type_t, const char *);
    162 extern void ddf_fun_destroy(function_t *);
    163 extern int ddf_fun_bind(function_t *);
    164 extern int ddf_fun_add_match_id(function_t *, const char *, int);
    165 
    166 extern void *function_get_ops(function_t *, dev_inferface_idx_t);
     155int ddf_driver_main(driver_t *);
     156
     157extern ddf_fun_t *ddf_fun_create(ddf_dev_t *, fun_type_t, const char *);
     158extern void ddf_fun_destroy(ddf_fun_t *);
     159extern int ddf_fun_bind(ddf_fun_t *);
     160extern int ddf_fun_add_match_id(ddf_fun_t *, const char *, int);
     161
     162extern void *function_get_ops(ddf_fun_t *, dev_inferface_idx_t);
    167163
    168164/*
     
    170166 */
    171167
    172 typedef void interrupt_handler_t(device_t *, ipc_callid_t, ipc_call_t *);
     168typedef void interrupt_handler_t(ddf_dev_t *, ipc_callid_t, ipc_call_t *);
    173169
    174170typedef struct interrupt_context {
    175171        int id;
    176         device_t *dev;
     172        ddf_dev_t *dev;
    177173        int irq;
    178174        interrupt_handler_t *handler;
     
    196192    interrupt_context_list_t *, int);
    197193extern interrupt_context_t *find_interrupt_context(
    198     interrupt_context_list_t *, device_t *, int);
    199 
    200 extern int register_interrupt_handler(device_t *, int, interrupt_handler_t *,
     194    interrupt_context_list_t *, ddf_dev_t *, int);
     195
     196extern int register_interrupt_handler(ddf_dev_t *, int, interrupt_handler_t *,
    201197    irq_code_t *);
    202 extern int unregister_interrupt_handler(device_t *, int);
    203 
    204 extern remote_handler_t *function_get_default_handler(function_t *);
    205 extern int add_function_to_class(function_t *fun, const char *class_name);
     198extern int unregister_interrupt_handler(ddf_dev_t *, int);
     199
     200extern remote_handler_t *function_get_default_handler(ddf_fun_t *);
     201extern int ddf_fun_add_to_class(ddf_fun_t *fun, const char *class_name);
    206202
    207203#endif
  • uspace/lib/drv/include/ops/char_dev.h

    r34588a80 r83a2f43  
    3939
    4040typedef struct {
    41         int (*read)(function_t *, char *, size_t);
    42         int (*write)(function_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

    r34588a80 r83a2f43  
    4242
    4343typedef struct {
    44          hw_resource_list_t *(*get_resource_list)(function_t *);
    45          bool (*enable_interrupt)(function_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/srv/devman/devman.h

    r34588a80 r83a2f43  
    161161        dev_node_t *dev;
    162162       
    163         /** Link to list of functions in the device (device_t.functions) */
     163        /** Link to list of functions in the device (ddf_dev_t.functions) */
    164164        link_t dev_functions;
    165165       
Note: See TracChangeset for help on using the changeset viewer.