Changeset 56fd7cf in mainline for uspace/drv/char


Ignore:
Timestamp:
2012-08-17T11:37:03Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1d5a540
Parents:
be2a38ad
Message:

Make ddf_dev_t and ddf_fun_t opaque. This further tighthens the DDF interface.

Location:
uspace/drv/char
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/char/i8042/i8042.c

    rbe2a38ad r56fd7cf  
    3939 */
    4040
    41 #include <devman.h>
    4241#include <device/hw_res.h>
    4342#include <ddi.h>
    … …  
    140139};
    141140
     141/** Get i8042 soft state from device node. */
     142static i8042_t *dev_i8042(ddf_dev_t *dev)
     143{
     144        return ddf_dev_data_get(dev);
     145}
     146
    142147/** Wait until it is safe to write to the device. */
    143148static void wait_ready(i8042_t *dev)
    … …  
    159164    ipc_call_t *call)
    160165{
    161         if ((!dev) || (!dev->driver_data))
    162                 return;
    163        
    164         i8042_t *controller = dev->driver_data;
     166        i8042_t *controller = dev_i8042(dev);
    165167       
    166168        const uint8_t status = IPC_GET_ARG1(*call);
    … …  
    188190    int irq_mouse, ddf_dev_t *ddf_dev)
    189191{
    190         assert(ddf_dev);
    191         assert(dev);
    192        
    193         if (reg_size < sizeof(i8042_regs_t))
    194                 return EINVAL;
    195        
    196         if (pio_enable(regs, sizeof(i8042_regs_t), (void **) &dev->regs) != 0)
    197                 return -1;
     192        const size_t range_count = sizeof(i8042_ranges) /
     193            sizeof(irq_pio_range_t);
     194        irq_pio_range_t ranges[range_count];
     195        const size_t cmd_count = sizeof(i8042_cmds) / sizeof(irq_cmd_t);
     196        irq_cmd_t cmds[cmd_count];
     197
     198        int rc;
     199        bool kbd_bound = false;
     200        bool aux_bound = false;
     201
     202        dev->kbd_fun = NULL;
     203        dev->aux_fun = NULL;
     204       
     205        if (reg_size < sizeof(i8042_regs_t)) {
     206                rc = EINVAL;
     207                goto error;
     208        }
     209       
     210        if (pio_enable(regs, sizeof(i8042_regs_t), (void **) &dev->regs) != 0) {
     211                rc = EIO;
     212                goto error;
     213        }
    198214       
    199215        dev->kbd_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2a");
    200         if (!dev->kbd_fun)
    201                 return ENOMEM;
    202        
    203         int ret = ddf_fun_add_match_id(dev->kbd_fun, "char/xtkbd", 90);
    204         if (ret != EOK) {
    205                 ddf_fun_destroy(dev->kbd_fun);
    206                 return ret;
    207         }
     216        if (dev->kbd_fun == NULL) {
     217                rc = ENOMEM;
     218                goto error;
     219        };
     220       
     221        rc = ddf_fun_add_match_id(dev->kbd_fun, "char/xtkbd", 90);
     222        if (rc != EOK)
     223                goto error;
    208224       
    209225        dev->aux_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2b");
    210         if (!dev->aux_fun) {
    211                 ddf_fun_destroy(dev->kbd_fun);
    212                 return ENOMEM;
    213         }
    214        
    215         ret = ddf_fun_add_match_id(dev->aux_fun, "char/ps2mouse", 90);
    216         if (ret != EOK) {
    217                 ddf_fun_destroy(dev->kbd_fun);
    218                 ddf_fun_destroy(dev->aux_fun);
    219                 return ret;
    220         }
    221        
    222         dev->kbd_fun->ops = &ops;
    223         dev->aux_fun->ops = &ops;
    224         dev->kbd_fun->driver_data = dev;
    225         dev->aux_fun->driver_data = dev;
     226        if (dev->aux_fun == NULL) {
     227                rc = ENOMEM;
     228                goto error;
     229        }
     230       
     231        rc = ddf_fun_add_match_id(dev->aux_fun, "char/ps2mouse", 90);
     232        if (rc != EOK)
     233                goto error;
     234       
     235        ddf_fun_set_ops(dev->kbd_fun, &ops);
     236        ddf_fun_set_ops(dev->aux_fun, &ops);
    226237       
    227238        buffer_init(&dev->kbd_buffer, dev->kbd_data, BUFFER_SIZE);
    … …  
    229240        fibril_mutex_initialize(&dev->write_guard);
    230241       
    231         ret = ddf_fun_bind(dev->kbd_fun);
    232         CHECK_RET_DESTROY(ret, "Failed to bind keyboard function: %s.",
    233             str_error(ret));
    234        
    235         ret = ddf_fun_bind(dev->aux_fun);
    236         CHECK_RET_DESTROY(ret, "Failed to bind mouse function: %s.",
    237             str_error(ret));
     242        rc = ddf_fun_bind(dev->kbd_fun);
     243        if (rc != EOK) {
     244                ddf_msg(LVL_ERROR, "Failed to bind keyboard function: %s.",
     245                    ddf_fun_get_name(dev->kbd_fun));
     246                goto error;
     247        }
     248        kbd_bound = true;
     249       
     250        rc = ddf_fun_bind(dev->aux_fun);
     251        if (rc != EOK) {
     252                ddf_msg(LVL_ERROR, "Failed to bind aux function: %s.",
     253                    ddf_fun_get_name(dev->aux_fun));
     254                goto error;
     255        }
     256        aux_bound = true;
    238257       
    239258        /* Disable kbd and aux */
    … …  
    247266                (void) pio_read_8(&dev->regs->data);
    248267
    249         const size_t range_count = sizeof(i8042_ranges) /
    250             sizeof(irq_pio_range_t);
    251         irq_pio_range_t ranges[range_count];
    252268        memcpy(ranges, i8042_ranges, sizeof(i8042_ranges));
    253269        ranges[0].base = (uintptr_t) regs;
    254270
    255         const size_t cmd_count = sizeof(i8042_cmds) / sizeof(irq_cmd_t);
    256         irq_cmd_t cmds[cmd_count];
    257271        memcpy(cmds, i8042_cmds, sizeof(i8042_cmds));
    258272        cmds[0].addr = (void *) &(((i8042_regs_t *) regs)->status);
    … …  
    266280        };
    267281       
    268         ret = register_interrupt_handler(ddf_dev, irq_kbd, i8042_irq_handler,
     282        rc = register_interrupt_handler(ddf_dev, irq_kbd, i8042_irq_handler,
    269283            &irq_code);
    270         CHECK_RET_UNBIND_DESTROY(ret, "Failed set handler for kbd: %s.",
    271             str_error(ret));
    272        
    273         ret = register_interrupt_handler(ddf_dev, irq_mouse, i8042_irq_handler,
     284        if (rc != EOK) {
     285                ddf_msg(LVL_ERROR, "Failed set handler for kbd: %s.",
     286                    ddf_dev_get_name(ddf_dev));
     287                goto error;
     288        }
     289       
     290        rc = register_interrupt_handler(ddf_dev, irq_mouse, i8042_irq_handler,
    274291            &irq_code);
    275         CHECK_RET_UNBIND_DESTROY(ret, "Failed set handler for mouse: %s.",
    276             str_error(ret));
     292        if (rc != EOK) {
     293                ddf_msg(LVL_ERROR, "Failed set handler for mouse: %s.",
     294                    ddf_dev_get_name(ddf_dev));
     295                goto error;
     296        }
    277297       
    278298        /* Enable interrupts */
    279         async_sess_t *parent_sess =
    280             devman_parent_device_connect(EXCHANGE_SERIALIZE, ddf_dev->handle,
    281             IPC_FLAG_BLOCKING);
    282         ret = parent_sess ? EOK : ENOMEM;
    283         CHECK_RET_UNBIND_DESTROY(ret, "Failed to create parent connection.");
     299        async_sess_t *parent_sess = ddf_dev_parent_sess_get(ddf_dev);
     300        assert(parent_sess != NULL);
    284301       
    285302        const bool enabled = hw_res_enable_interrupt(parent_sess);
    286         async_hangup(parent_sess);
    287         ret = enabled ? EOK : EIO;
    288         CHECK_RET_UNBIND_DESTROY(ret, "Failed to enable interrupts: %s.");
     303        if (!enabled) {
     304                log_msg(LVL_ERROR, "Failed to enable interrupts: %s.",
     305                    ddf_dev_get_name(ddf_dev));
     306                rc = EIO;
     307                goto error;
     308        }
    289309       
    290310        /* Enable port interrupts. */
    … …  
    296316       
    297317        return EOK;
     318error:
     319        if (kbd_bound)
     320                ddf_fun_unbind(dev->kbd_fun);
     321        if (aux_bound)
     322                ddf_fun_unbind(dev->aux_fun);
     323        if (dev->kbd_fun != NULL)
     324                ddf_fun_destroy(dev->kbd_fun);
     325        if (dev->aux_fun != NULL)
     326                ddf_fun_destroy(dev->aux_fun);
     327
     328        return rc;
    298329}
    299330
    … …  
    315346static int i8042_write(ddf_fun_t *fun, char *buffer, size_t size)
    316347{
    317         assert(fun);
    318         assert(fun->driver_data);
    319        
    320         i8042_t *controller = fun->driver_data;
     348        i8042_t *controller = dev_i8042(ddf_fun_get_dev(fun));
    321349        fibril_mutex_lock(&controller->write_guard);
    322350       
    … …  
    347375static int i8042_read(ddf_fun_t *fun, char *data, size_t size)
    348376{
    349         assert(fun);
    350         assert(fun->driver_data);
    351        
    352         i8042_t *controller = fun->driver_data;
     377        i8042_t *controller = dev_i8042(ddf_fun_get_dev(fun));
    353378        buffer_t *buffer = (fun == controller->aux_fun) ?
    354379            &controller->aux_buffer : &controller->kbd_buffer;

  • uspace/drv/char/i8042/main.c

    rbe2a38ad r56fd7cf  
    3737#include <libarch/inttypes.h>
    3838#include <ddf/driver.h>
    39 #include <devman.h>
    4039#include <device/hw_res_parsed.h>
    4140#include <errno.h>
    … …  
    6463 *
    6564 */
    66 static int get_my_registers(const ddf_dev_t *dev, uintptr_t *io_reg_address,
     65static int get_my_registers(ddf_dev_t *dev, uintptr_t *io_reg_address,
    6766    size_t *io_reg_size, int *kbd_irq, int *mouse_irq)
    6867{
    6968        assert(dev);
    7069       
    71         async_sess_t *parent_sess =
    72             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
    73             IPC_FLAG_BLOCKING);
    74         if (!parent_sess)
     70        async_sess_t *parent_sess = ddf_dev_parent_sess_create(
     71            dev, EXCHANGE_SERIALIZE);
     72        if (parent_sess == NULL)
    7573                return ENOMEM;
    7674       
    … …  
    7876        hw_res_list_parsed_init(&hw_resources);
    7977        const int ret = hw_res_get_list_parsed(parent_sess, &hw_resources, 0);
    80         async_hangup(parent_sess);
    8178        if (ret != EOK)
    8279                return ret;
    … …  
    136133       
    137134        ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
    138             device->name, device->handle);
     135            ddf_dev_get_name(device), ddf_dev_get_handle(device));
    139136        return EOK;
    140137}

  • uspace/drv/char/ns8250/ns8250.c

    rbe2a38ad r56fd7cf  
    5858#include <ops/char_dev.h>
    5959
    60 #include <devman.h>
    6160#include <ns.h>
    62 #include <ipc/devman.h>
    6361#include <ipc/services.h>
    6462#include <ipc/irc.h>
    … …  
    127125#define NS8250_MSR_SIGNALS      (NS8250_MSR_CTS | NS8250_MSR_DSR \
    128126    | NS8250_MSR_RI | NS8250_MSR_DCD)
    129 
    130 /** Obtain soft-state structure from function node */
    131 #define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
    132 
    133 /** Obtain soft-state structure from device node */
    134 #define NS8250_FROM_DEV(dnode) ((ns8250_t *) ((dnode)->driver_data))
    135127
    136128/** The number of bits of one data unit send by the serial port. */
    … …  
    187179} ns8250_t;
    188180
     181/** Obtain soft-state structure from device node */
     182static ns8250_t *dev_ns8250(ddf_dev_t *dev)
     183{
     184        return ddf_dev_data_get(dev);
     185}
     186
     187/** Obtain soft-state structure from function node */
     188static ns8250_t *fun_ns8250(ddf_fun_t *fun)
     189{
     190        return dev_ns8250(ddf_fun_get_dev(fun));
     191}
     192
    189193/** Find out if there is some incomming data available on the serial port.
    190194 *
    … …  
    241245static int ns8250_read(ddf_fun_t *fun, char *buf, size_t count)
    242246{
    243         ns8250_t *ns = NS8250(fun);
     247        ns8250_t *ns = fun_ns8250(fun);
    244248        int ret = 0;
    245249       
    … …  
    279283static int ns8250_write(ddf_fun_t *fun, char *buf, size_t count)
    280284{
    281         ns8250_t *ns = NS8250(fun);
     285        ns8250_t *ns = fun_ns8250(fun);
    282286        size_t idx;
    283287       
    … …  
    317321static void ns8250_dev_cleanup(ns8250_t *ns)
    318322{
    319         if (ns->dev->parent_sess) {
    320                 async_hangup(ns->dev->parent_sess);
    321                 ns->dev->parent_sess = NULL;
    322         }
    323323}
    324324
    … …  
    330330static bool ns8250_pio_enable(ns8250_t *ns)
    331331{
    332         ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s", ns->dev->name);
     332        ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s", ddf_dev_get_name(ns->dev));
    333333       
    334334        /* Gain control over port's registers. */
    … …  
    336336            (void **) &ns->port)) {
    337337                ddf_msg(LVL_ERROR, "Cannot map the port %#" PRIx32
    338                     " for device %s.", ns->io_addr, ns->dev->name);
     338                    " for device %s.", ns->io_addr, ddf_dev_get_name(ns->dev));
    339339                return false;
    340340        }
    … …  
    352352static bool ns8250_dev_probe(ns8250_t *ns)
    353353{
    354         ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
     354        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ddf_dev_get_name(ns->dev));
    355355       
    356356        bool res = true;
    … …  
    372372        if (!res) {
    373373                ddf_msg(LVL_DEBUG, "Device %s is not present.",
    374                     ns->dev->name);
     374                    ddf_dev_get_name(ns->dev));
    375375        }
    376376       
    … …  
    385385static int ns8250_dev_initialize(ns8250_t *ns)
    386386{
    387         ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s", ns->dev->name);
    388        
     387        async_sess_t *parent_sess;
    389388        int ret = EOK;
     389       
     390        ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s", ddf_dev_get_name(ns->dev));
    390391       
    391392        hw_resource_list_t hw_resources;
    … …  
    393394       
    394395        /* Connect to the parent's driver. */
    395         ns->dev->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
    396             ns->dev->handle, IPC_FLAG_BLOCKING);
    397         if (!ns->dev->parent_sess) {
     396        parent_sess = ddf_dev_parent_sess_create(ns->dev, EXCHANGE_SERIALIZE);
     397        if (parent_sess == NULL) {
    398398                ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
    399                     "device %s.", ns->dev->name);
     399                    "device %s.", ddf_dev_get_name(ns->dev));
    400400                ret = ENOENT;
    401401                goto failed;
    … …  
    403403       
    404404        /* Get hw resources. */
    405         ret = hw_res_get_resource_list(ns->dev->parent_sess, &hw_resources);
     405        ret = hw_res_get_resource_list(parent_sess, &hw_resources);
    406406        if (ret != EOK) {
    407407                ddf_msg(LVL_ERROR, "Failed to get HW resources for device "
    408                     "%s.", ns->dev->name);
     408                    "%s.", ddf_dev_get_name(ns->dev));
    409409                goto failed;
    410410        }
    … …  
    422422                        irq = true;
    423423                        ddf_msg(LVL_NOTE, "Device %s was asigned irq = 0x%x.",
    424                             ns->dev->name, ns->irq);
     424                            ddf_dev_get_name(ns->dev), ns->irq);
    425425                        break;
    426426                       
    … …  
    429429                        if (res->res.io_range.size < REG_COUNT) {
    430430                                ddf_msg(LVL_ERROR, "I/O range assigned to "
    431                                     "device %s is too small.", ns->dev->name);
     431                                    "device %s is too small.", ddf_dev_get_name(ns->dev));
    432432                                ret = ELIMIT;
    433433                                goto failed;
    … …  
    435435                        ioport = true;
    436436                        ddf_msg(LVL_NOTE, "Device %s was asigned I/O address = "
    437                             "0x%x.", ns->dev->name, ns->io_addr);
     437                            "0x%x.", ddf_dev_get_name(ns->dev), ns->io_addr);
    438438                        break;
    439439                       
    … …  
    445445        if (!irq || !ioport) {
    446446                ddf_msg(LVL_ERROR, "Missing HW resource(s) for device %s.",
    447                     ns->dev->name);
     447                    ddf_dev_get_name(ns->dev));
    448448                ret = ENOENT;
    449449                goto failed;
    … …  
    613613        *parity = ((val >> NS8250_LCR_PARITY) & 7);
    614614       
     615        /* Silence warnings */
     616        *word_length = 0;
     617
    615618        switch (val & 3) {
    616619        case WORD_LENGTH_5:
    … …  
    755758                                if (!buf_push_back(&ns->input_buffer, val)) {
    756759                                        ddf_msg(LVL_WARN, "Buffer overflow on "
    757                                             "%s.", ns->dev->name);
     760                                            "%s.", ddf_dev_get_name(ns->dev));
    758761                                        break;
    759762                                } else {
    760763                                        ddf_msg(LVL_DEBUG2, "Character %c saved "
    761764                                            "to the buffer of %s.",
    762                                             val, ns->dev->name);
     765                                            val, ddf_dev_get_name(ns->dev));
    763766                                        if (buf_was_empty)
    764767                                                fibril_condvar_broadcast(&ns->input_buffer_available);
    … …  
    782785    ipc_call_t *icall)
    783786{
    784         ns8250_t *ns = NS8250_FROM_DEV(dev);
     787        ns8250_t *ns = dev_ns8250(dev);
    785788
    786789        uint8_t iir = pio_read_8(&ns->regs->iid);
    … …  
    788791                uint8_t lsr = pio_read_8(&ns->regs->lsr);
    789792                if (lsr & NS8250_LSR_OE) {
    790                         ddf_msg(LVL_WARN, "Overrun error on %s", ns->dev->name);
     793                        ddf_msg(LVL_WARN, "Overrun error on %s", ddf_dev_get_name(ns->dev));
    791794                }
    792795        }
    … …  
    828831       
    829832        ddf_msg(LVL_DEBUG, "ns8250_dev_add %s (handle = %d)",
    830             dev->name, (int) dev->handle);
     833            ddf_dev_get_name(dev), (int) ddf_dev_get_handle(dev));
    831834       
    832835        /* Allocate soft-state for the device */
    … …  
    883886       
    884887        /* Set device operations. */
    885         fun->ops = &ns8250_dev_ops;
     888        ddf_fun_set_ops(fun, &ns8250_dev_ops);
    886889        rc = ddf_fun_bind(fun);
    887890        if (rc != EOK) {
    … …  
    895898       
    896899        ddf_msg(LVL_NOTE, "Device %s successfully initialized.",
    897             dev->name);
     900            ddf_dev_get_name(dev));
    898901       
    899902        return EOK;
    … …  
    908911static int ns8250_dev_remove(ddf_dev_t *dev)
    909912{
    910         ns8250_t *ns = NS8250_FROM_DEV(dev);
     913        ns8250_t *ns = dev_ns8250(dev);
    911914        int rc;
    912915       
    … …  
    942945static int ns8250_open(ddf_fun_t *fun)
    943946{
    944         ns8250_t *ns = NS8250(fun);
     947        ns8250_t *ns = fun_ns8250(fun);
    945948        int res;
    946949       
    … …  
    968971static void ns8250_close(ddf_fun_t *fun)
    969972{
    970         ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
     973        ns8250_t *data = fun_ns8250(fun);
    971974       
    972975        fibril_mutex_lock(&data->mutex);
    … …  
    993996    unsigned int *word_length, unsigned int* stop_bits)
    994997{
    995         ns8250_t *data = (ns8250_t *) dev->driver_data;
     998        ns8250_t *data = dev_ns8250(dev);
    996999        ns8250_regs_t *regs = data->regs;
    9971000       
    … …  
    10241027            stop_bits);
    10251028       
    1026         ns8250_t *data = (ns8250_t *) dev->driver_data;
     1029        ns8250_t *data = dev_ns8250(dev);
    10271030        ns8250_regs_t *regs = data->regs;
    10281031        int ret;
    … …  
    10531056        switch (method) {
    10541057        case SERIAL_GET_COM_PROPS:
    1055                 ns8250_get_props(fun->dev, &baud_rate, &parity, &word_length,
     1058                ns8250_get_props(ddf_fun_get_dev(fun), &baud_rate, &parity, &word_length,
    10561059                    &stop_bits);
    10571060                async_answer_4(callid, EOK, baud_rate, parity, word_length,
    … …  
    10641067                word_length = IPC_GET_ARG3(*call);
    10651068                stop_bits = IPC_GET_ARG4(*call);
    1066                 ret = ns8250_set_props(fun->dev, baud_rate, parity, word_length,
     1069                ret = ns8250_set_props(ddf_fun_get_dev(fun), baud_rate, parity, word_length,
    10671070                    stop_bits);
    10681071                async_answer_0(callid, ret);

  • uspace/drv/char/ps2mouse/main.c

    rbe2a38ad r56fd7cf  
    9898
    9999        ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
    100             device->name, device->handle);
     100            ddf_dev_get_name(device), ddf_dev_get_handle(device));
    101101        return EOK;
    102102}

  • uspace/drv/char/ps2mouse/ps2mouse.c

    rbe2a38ad r56fd7cf  
    3535#include <bool.h>
    3636#include <errno.h>
    37 #include <devman.h>
    3837#include <ddf/log.h>
    3938#include <io/keycode.h>
    … …  
    114113int ps2_mouse_init(ps2_mouse_t *mouse, ddf_dev_t *dev)
    115114{
    116         assert(mouse);
    117         assert(dev);
    118115        mouse->client_sess = NULL;
    119         mouse->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
    120             dev->handle, IPC_FLAG_BLOCKING);
     116        mouse->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
    121117        if (!mouse->parent_sess)
    122118                return ENOMEM;
    … …  
    124120        mouse->mouse_fun = ddf_fun_create(dev, fun_exposed, "mouse");
    125121        if (!mouse->mouse_fun) {
    126                 async_hangup(mouse->parent_sess);
    127                 return ENOMEM;
    128         }
    129         mouse->mouse_fun->ops = &mouse_ops;
    130         mouse->mouse_fun->driver_data = mouse;
     122                return ENOMEM;
     123        }
     124        ddf_fun_set_ops(mouse->mouse_fun, &mouse_ops);
    131125
    132126        int ret = ddf_fun_bind(mouse->mouse_fun);
    133127        if (ret != EOK) {
    134                 async_hangup(mouse->parent_sess);
    135                 mouse->mouse_fun->driver_data = NULL;
    136128                ddf_fun_destroy(mouse->mouse_fun);
    137129                return ENOMEM;
    … …  
    140132        ret = ddf_fun_add_to_category(mouse->mouse_fun, "mouse");
    141133        if (ret != EOK) {
    142                 async_hangup(mouse->parent_sess);
    143134                ddf_fun_unbind(mouse->mouse_fun);
    144                 mouse->mouse_fun->driver_data = NULL;
    145135                ddf_fun_destroy(mouse->mouse_fun);
    146136                return ENOMEM;
    … …  
    161151                ddf_msg(LVL_ERROR, "Failed to enable data reporting.");
    162152                async_exchange_end(exch);
    163                 async_hangup(mouse->parent_sess);
    164153                ddf_fun_unbind(mouse->mouse_fun);
    165                 mouse->mouse_fun->driver_data = NULL;
    166154                ddf_fun_destroy(mouse->mouse_fun);
    167155                return EIO;
    … …  
    173161                ddf_msg(LVL_ERROR, "Failed to confirm data reporting: %hhx.",
    174162                    report);
    175                 async_hangup(mouse->parent_sess);
    176163                ddf_fun_unbind(mouse->mouse_fun);
    177                 mouse->mouse_fun->driver_data = NULL;
    178164                ddf_fun_destroy(mouse->mouse_fun);
    179165                return EIO;
    … …  
    182168        mouse->polling_fibril = fibril_create(polling_f, mouse);
    183169        if (!mouse->polling_fibril) {
    184                 async_hangup(mouse->parent_sess);
    185170                ddf_fun_unbind(mouse->mouse_fun);
    186                 mouse->mouse_fun->driver_data = NULL;
    187171                ddf_fun_destroy(mouse->mouse_fun);
    188172                return ENOMEM;
    … …  
    368352    ipc_callid_t icallid, ipc_call_t *icall)
    369353{
    370         if (fun == NULL || fun->driver_data == NULL) {
    371                 ddf_msg(LVL_ERROR, "%s: Missing parameter.", __FUNCTION__);
    372                 async_answer_0(icallid, EINVAL);
    373                 return;
    374         }
    375 
    376354        const sysarg_t method = IPC_GET_IMETHOD(*icall);
    377         ps2_mouse_t *mouse = fun->driver_data;
     355        ps2_mouse_t *mouse = ddf_dev_data_get(ddf_fun_get_dev(fun));
    378356
    379357        switch (method) {

  • uspace/drv/char/xtkbd/main.c

    rbe2a38ad r56fd7cf  
    9898
    9999        ddf_msg(LVL_NOTE, "Controlling '%s' (%" PRIun ").",
    100             device->name, device->handle);
     100            ddf_dev_get_name(device), ddf_dev_get_handle(device));
    101101        return EOK;
    102102}

  • uspace/drv/char/xtkbd/xtkbd.c

    rbe2a38ad r56fd7cf  
    3434
    3535#include <errno.h>
    36 #include <devman.h>
    3736#include <ddf/log.h>
    3837#include <io/keycode.h>
    … …  
    207206        assert(dev);
    208207        kbd->client_sess = NULL;
    209         kbd->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
    210             dev->handle, IPC_FLAG_BLOCKING);
     208        kbd->parent_sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
    211209        if (!kbd->parent_sess)
    212210                return ENOMEM;
    … …  
    214212        kbd->kbd_fun = ddf_fun_create(dev, fun_exposed, "kbd");
    215213        if (!kbd->kbd_fun) {
    216                 async_hangup(kbd->parent_sess);
    217                 return ENOMEM;
    218         }
    219         kbd->kbd_fun->ops = &kbd_ops;
    220         kbd->kbd_fun->driver_data = kbd;
     214                return ENOMEM;
     215        }
     216        ddf_fun_set_ops(kbd->kbd_fun, &kbd_ops);
    221217
    222218        int ret = ddf_fun_bind(kbd->kbd_fun);
    223219        if (ret != EOK) {
    224                 async_hangup(kbd->parent_sess);
    225                 kbd->kbd_fun->driver_data = NULL;
    226220                ddf_fun_destroy(kbd->kbd_fun);
    227221                return ENOMEM;
    … …  
    230224        ret = ddf_fun_add_to_category(kbd->kbd_fun, "keyboard");
    231225        if (ret != EOK) {
    232                 async_hangup(kbd->parent_sess);
    233226                ddf_fun_unbind(kbd->kbd_fun);
    234                 kbd->kbd_fun->driver_data = NULL;
    235227                ddf_fun_destroy(kbd->kbd_fun);
    236228                return ENOMEM;
    … …  
    239231        kbd->polling_fibril = fibril_create(polling, kbd);
    240232        if (!kbd->polling_fibril) {
    241                 async_hangup(kbd->parent_sess);
    242233                ddf_fun_unbind(kbd->kbd_fun);
    243                 kbd->kbd_fun->driver_data = NULL;
    244234                ddf_fun_destroy(kbd->kbd_fun);
    245235                return ENOMEM;
    … …  
    319309    ipc_callid_t icallid, ipc_call_t *icall)
    320310{
    321         if (fun == NULL || fun->driver_data == NULL) {
    322                 ddf_msg(LVL_ERROR, "%s: Missing parameter.", __FUNCTION__);
    323                 async_answer_0(icallid, EINVAL);
    324                 return;
    325         }
    326 
    327311        const sysarg_t method = IPC_GET_IMETHOD(*icall);
    328         xt_kbd_t *kbd = fun->driver_data;
     312        xt_kbd_t *kbd = ddf_dev_data_get(ddf_fun_get_dev(fun));
    329313
    330314        switch (method) {
Note: See TracChangeset for help on using the changeset viewer.