Changeset ad7a6c9 in mainline for uspace/drv/ns8250/ns8250.c


Ignore:
Timestamp:
2011-03-30T13:10:24Z (14 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4ae90f9
Parents:
6e50466 (diff), d6b81941 (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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ns8250/ns8250.c

    r6e50466 rad7a6c9  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    5253#include <libarch/ddi.h>
    5354
    54 #include <driver.h>
    55 #include <char.h>
    56 #include <resource.h>
     55#include <ddf/driver.h>
     56#include <ddf/interrupt.h>
     57#include <ops/char_dev.h>
    5758
    5859#include <devman.h>
    … …  
    6869#define MAX_BAUD_RATE 115200
    6970#define DLAB_MASK (1 << 7)
     71
     72/** Obtain soft-state structure from function node */
     73#define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
     74
     75/** Obtain soft-state structure from device node */
     76#define NS8250_FROM_DEV(dnode) ((ns8250_t *) ((dnode)->driver_data))
    7077
    7178/** The number of bits of one data unit send by the serial port. */
    … …  
    8693
    8794/** The driver data for the serial port devices. */
    88 typedef struct ns8250_dev_data {
     95typedef struct ns8250 {
     96        /** DDF device node */
     97        ddf_dev_t *dev;
     98        /** DDF function node */
     99        ddf_fun_t *fun;
    89100        /** Is there any client conntected to the device? */
    90101        bool client_connected;
    … …  
    99110        /** The fibril mutex for synchronizing the access to the device. */
    100111        fibril_mutex_t mutex;
    101 } ns8250_dev_data_t;
    102 
    103 /** Create driver data for a device.
    104  *
    105  * @return              The driver data.
    106  */
    107 static ns8250_dev_data_t *create_ns8250_dev_data(void)
    108 {
    109         ns8250_dev_data_t *data;
    110        
    111         data = (ns8250_dev_data_t *) malloc(sizeof(ns8250_dev_data_t));
    112         if (NULL != data) {
    113                 memset(data, 0, sizeof(ns8250_dev_data_t));
    114                 fibril_mutex_initialize(&data->mutex);
    115         }
    116         return data;
    117 }
    118 
    119 /** Delete driver data.
    120  *
    121  * @param data          The driver data structure.
    122  */
    123 static void delete_ns8250_dev_data(ns8250_dev_data_t *data)
    124 {
    125         if (data != NULL)
    126                 free(data);
     112} ns8250_t;
     113
     114/** Create per-device soft-state structure.
     115 *
     116 * @return      Pointer to soft-state structure.
     117 */
     118static ns8250_t *ns8250_new(void)
     119{
     120        ns8250_t *ns;
     121       
     122        ns = (ns8250_t *) calloc(1, sizeof(ns8250_t));
     123        if (ns == NULL)
     124                return NULL;
     125       
     126        fibril_mutex_initialize(&ns->mutex);
     127        return ns;
     128}
     129
     130/** Delete soft-state structure.
     131 *
     132 * @param ns    The driver data structure.
     133 */
     134static void ns8250_delete(ns8250_t *ns)
     135{
     136        assert(ns != NULL);
     137        free(ns);
    127138}
    128139
    … …  
    172183/** Read data from the serial port device.
    173184 *
    174  * @param dev           The serial port device.
     185 * @param fun           The serial port function
    175186 * @param buf           The ouput buffer for read data.
    176187 * @param count         The number of bytes to be read.
    … …  
    179190 *                      error number otherwise.
    180191 */
    181 static int ns8250_read(device_t *dev, char *buf, size_t count)
    182 {
     192static int ns8250_read(ddf_fun_t *fun, char *buf, size_t count)
     193{
     194        ns8250_t *ns = NS8250(fun);
    183195        int ret = EOK;
    184         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    185        
    186         fibril_mutex_lock(&data->mutex);
    187         while (!buf_is_empty(&data->input_buffer) && (size_t)ret < count) {
    188                 buf[ret] = (char)buf_pop_front(&data->input_buffer);
     196       
     197        fibril_mutex_lock(&ns->mutex);
     198        while (!buf_is_empty(&ns->input_buffer) && (size_t)ret < count) {
     199                buf[ret] = (char)buf_pop_front(&ns->input_buffer);
    189200                ret++;
    190201        }
    191         fibril_mutex_unlock(&data->mutex);
     202        fibril_mutex_unlock(&ns->mutex);
    192203       
    193204        return ret;
    … …  
    196207/** Write a character to the serial port.
    197208 *
    198  * @param data          The serial port device's driver data.
    199  * @param c             The character to be written.
    200  */
    201 static inline void ns8250_putchar(ns8250_dev_data_t *data, uint8_t c)
    202 {
    203         fibril_mutex_lock(&data->mutex);
    204         ns8250_write_8(data->port, c);
    205         fibril_mutex_unlock(&data->mutex);
     209 * @param ns            Serial port device
     210 * @param c             The character to be written
     211 */
     212static inline void ns8250_putchar(ns8250_t *ns, uint8_t c)
     213{
     214        fibril_mutex_lock(&ns->mutex);
     215        ns8250_write_8(ns->port, c);
     216        fibril_mutex_unlock(&ns->mutex);
    206217}
    207218
    208219/** Write data to the serial port.
    209220 *
    210  * @param dev           The serial port device.
    211  * @param buf           The data to be written.
    212  * @param count         The number of bytes to be written.
    213  * @return              Zero on success.
    214  */
    215 static int ns8250_write(device_t *dev, char *buf, size_t count)
    216 {
    217         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     221 * @param fun           The serial port function
     222 * @param buf           The data to be written
     223 * @param count         The number of bytes to be written
     224 * @return              Zero on success
     225 */
     226static int ns8250_write(ddf_fun_t *fun, char *buf, size_t count)
     227{
     228        ns8250_t *ns = NS8250(fun);
    218229        size_t idx;
    219230       
    220231        for (idx = 0; idx < count; idx++)
    221                 ns8250_putchar(data, (uint8_t) buf[idx]);
     232                ns8250_putchar(ns, (uint8_t) buf[idx]);
    222233       
    223234        return 0;
    224235}
    225236
    226 static device_ops_t ns8250_dev_ops;
     237static ddf_dev_ops_t ns8250_dev_ops;
    227238
    228239/** The character interface's callbacks. */
    229 static char_iface_t ns8250_char_iface = {
     240static char_dev_ops_t ns8250_char_dev_ops = {
    230241        .read = &ns8250_read,
    231242        .write = &ns8250_write
    232243};
    233244
    234 static int ns8250_add_device(device_t *dev);
     245static int ns8250_add_device(ddf_dev_t *dev);
    235246
    236247/** The serial port device driver's standard operations. */
    … …  
    245256};
    246257
    247 /** Clean up the serial port device structure.
    248  *
    249  * @param dev           The device structure.
    250  */
    251 static void ns8250_dev_cleanup(device_t *dev)
    252 {
    253         if (dev->driver_data != NULL) {
    254                 delete_ns8250_dev_data((ns8250_dev_data_t*) dev->driver_data);
    255                 dev->driver_data = NULL;
    256         }
    257        
    258         if (dev->parent_phone > 0) {
    259                 ipc_hangup(dev->parent_phone);
    260                 dev->parent_phone = 0;
     258/** Clean up the serial port soft-state
     259 *
     260 * @param ns            Serial port device
     261 */
     262static void ns8250_dev_cleanup(ns8250_t *ns)
     263{
     264        if (ns->dev->parent_phone > 0) {
     265                async_hangup(ns->dev->parent_phone);
     266                ns->dev->parent_phone = 0;
    261267        }
    262268}
    … …  
    264270/** Enable the i/o ports of the device.
    265271 *
    266  * @param dev           The serial port device.
    267  * @return              True on success, false otherwise.
    268  */
    269 static bool ns8250_pio_enable(device_t *dev)
    270 {
    271         printf(NAME ": ns8250_pio_enable %s\n", dev->name);
    272        
    273         ns8250_dev_data_t *data = (ns8250_dev_data_t *)dev->driver_data;
     272 * @param ns            Serial port device
     273 * @return              True on success, false otherwise
     274 */
     275static bool ns8250_pio_enable(ns8250_t *ns)
     276{
     277        printf(NAME ": ns8250_pio_enable %s\n", ns->dev->name);
    274278       
    275279        /* Gain control over port's registers. */
    276         if (pio_enable((void *)(uintptr_t) data->io_addr, REG_COUNT,
    277             (void **) &data->port)) {
     280        if (pio_enable((void *)(uintptr_t) ns->io_addr, REG_COUNT,
     281            (void **) &ns->port)) {
    278282                printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
    279                     "%s.\n", data->io_addr, dev->name);
     283                    "%s.\n", ns->io_addr, ns->dev->name);
    280284                return false;
    281285        }
    … …  
    286290/** Probe the serial port device for its presence.
    287291 *
    288  * @param dev           The serial port device.
    289  * @return              True if the device is present, false otherwise.
    290  */
    291 static bool ns8250_dev_probe(device_t *dev)
    292 {
    293         printf(NAME ": ns8250_dev_probe %s\n", dev->name);
    294        
    295         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    296         ioport8_t *port_addr = data->port;
     292 * @param ns            Serial port device
     293 * @return              True if the device is present, false otherwise
     294 */
     295static bool ns8250_dev_probe(ns8250_t *ns)
     296{
     297        printf(NAME ": ns8250_dev_probe %s\n", ns->dev->name);
     298       
     299        ioport8_t *port_addr = ns->port;
    297300        bool res = true;
    298301        uint8_t olddata;
    … …  
    311314       
    312315        if (!res)
    313                 printf(NAME ": device %s is not present.\n", dev->name);
     316                printf(NAME ": device %s is not present.\n", ns->dev->name);
    314317       
    315318        return res;
    … …  
    318321/** Initialize serial port device.
    319322 *
    320  * @param dev           The serial port device.
    321  * @return              Zero on success, negative error number otherwise.
    322  */
    323 static int ns8250_dev_initialize(device_t *dev)
    324 {
    325         printf(NAME ": ns8250_dev_initialize %s\n", dev->name);
     323 * @param ns            Serial port device
     324 * @return              Zero on success, negative error number otherwise
     325 */
     326static int ns8250_dev_initialize(ns8250_t *ns)
     327{
     328        printf(NAME ": ns8250_dev_initialize %s\n", ns->dev->name);
    326329       
    327330        int ret = EOK;
    … …  
    330333        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    331334       
    332         /* Allocate driver data for the device. */
    333         ns8250_dev_data_t *data = create_ns8250_dev_data();
    334         if (data == NULL)
    335                 return ENOMEM;
    336         dev->driver_data = data;
    337        
    338335        /* Connect to the parent's driver. */
    339         dev->parent_phone = devman_parent_device_connect(dev->handle,
     336        ns->dev->parent_phone = devman_parent_device_connect(ns->dev->handle,
    340337            IPC_FLAG_BLOCKING);
    341         if (dev->parent_phone < 0) {
     338        if (ns->dev->parent_phone < 0) {
    342339                printf(NAME ": failed to connect to the parent driver of the "
    343                     "device %s.\n", dev->name);
    344                 ret = EPARTY;   /* FIXME: use another EC */
     340                    "device %s.\n", ns->dev->name);
     341                ret = ns->dev->parent_phone;
    345342                goto failed;
    346343        }
    347344       
    348345        /* Get hw resources. */
    349         if (!get_hw_resources(dev->parent_phone, &hw_resources)) {
     346        ret = hw_res_get_resource_list(ns->dev->parent_phone, &hw_resources);
     347        if (ret != EOK) {
    350348                printf(NAME ": failed to get hw resources for the device "
    351                     "%s.\n", dev->name);
    352                 ret = EPARTY;   /* FIXME: use another EC */
     349                    "%s.\n", ns->dev->name);
    353350                goto failed;
    354351        }
    … …  
    363360                switch (res->type) {
    364361                case INTERRUPT:
    365                         data->irq = res->res.interrupt.irq;
     362                        ns->irq = res->res.interrupt.irq;
    366363                        irq = true;
    367364                        printf(NAME ": the %s device was asigned irq = 0x%x.\n",
    368                             dev->name, data->irq);
     365                            ns->dev->name, ns->irq);
    369366                        break;
    370367                       
    371368                case IO_RANGE:
    372                         data->io_addr = res->res.io_range.address;
     369                        ns->io_addr = res->res.io_range.address;
    373370                        if (res->res.io_range.size < REG_COUNT) {
    374371                                printf(NAME ": i/o range assigned to the device "
    375                                     "%s is too small.\n", dev->name);
    376                                 ret = EPARTY;   /* FIXME: use another EC */
     372                                    "%s is too small.\n", ns->dev->name);
     373                                ret = ELIMIT;
    377374                                goto failed;
    378375                        }
    379376                        ioport = true;
    380377                        printf(NAME ": the %s device was asigned i/o address = "
    381                             "0x%x.\n", dev->name, data->io_addr);
     378                            "0x%x.\n", ns->dev->name, ns->io_addr);
    382379                        break;
    383380                       
    … …  
    389386        if (!irq || !ioport) {
    390387                printf(NAME ": missing hw resource(s) for the device %s.\n",
    391                     dev->name);
    392                 ret = EPARTY;   /* FIXME: use another EC */
     388                    ns->dev->name);
     389                ret = ENOENT;
    393390                goto failed;
    394391        }
    395392       
    396         clean_hw_resource_list(&hw_resources);
     393        hw_res_clean_resource_list(&hw_resources);
    397394        return ret;
    398395       
    399396failed:
    400         ns8250_dev_cleanup(dev);
    401         clean_hw_resource_list(&hw_resources);
     397        ns8250_dev_cleanup(ns);
     398        hw_res_clean_resource_list(&hw_resources);
    402399        return ret;
    403400}
    … …  
    405402/** Enable interrupts on the serial port device.
    406403 *
    407  * Interrupt when data is received.
     404 * Interrupt when data is received
    408405 *
    409406 * @param port          The base address of the serial port device's ports.
    410407 */
    411408static inline void ns8250_port_interrupts_enable(ioport8_t *port)
    412 {       
     409{
    413410        pio_write_8(port + 1, 0x1);     /* Interrupt when data received. */
    414411        pio_write_8(port + 4, 0xB);
    … …  
    417414/** Disable interrupts on the serial port device.
    418415 *
    419  * @param port          The base address of the serial port device's ports.
     416 * @param port          The base address of the serial port device's ports
    420417 */
    421418static inline void ns8250_port_interrupts_disable(ioport8_t *port)
    … …  
    426423/** Enable interrupts for the serial port device.
    427424 *
    428  * @param dev           The device.
    429  * @return              Zero on success, negative error number otherwise.
    430  */
    431 static int ns8250_interrupt_enable(device_t *dev)
    432 {
    433         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    434         int res;
    435        
    436         /* Enable interrupt globally. */
    437         res = interrupt_enable(data->irq);
    438         if (res != EOK)
    439                 return res;
    440        
     425 * @param ns            Serial port device
     426 * @return              Zero on success, negative error number otherwise
     427 */
     428static int ns8250_interrupt_enable(ns8250_t *ns)
     429{
    441430        /* Enable interrupt on the serial port. */
    442         ns8250_port_interrupts_enable(data->port);
     431        ns8250_port_interrupts_enable(ns->port);
    443432       
    444433        return EOK;
    … …  
    625614 * Set the default parameters of the serial communication.
    626615 *
    627  * @param dev           The serial port device.
    628  */
    629 static void ns8250_initialize_port(device_t *dev)
    630 {
    631         ns8250_dev_data_t *data = (ns8250_dev_data_t *)dev->driver_data;
    632         ioport8_t *port = data->port;
     616 * @param ns            Serial port device
     617 */
     618static void ns8250_initialize_port(ns8250_t *ns)
     619{
     620        ioport8_t *port = ns->port;
    633621       
    634622        /* Disable interrupts. */
    … …  
    650638 * buffer.
    651639 *
    652  * @param dev           The serial port device.
    653  */
    654 static void ns8250_read_from_device(device_t *dev)
    655 {
    656         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    657         ioport8_t *port = data->port;
     640 * @param ns            Serial port device
     641 */
     642static void ns8250_read_from_device(ns8250_t *ns)
     643{
     644        ioport8_t *port = ns->port;
    658645        bool cont = true;
    659646       
    660647        while (cont) {
    661                 fibril_mutex_lock(&data->mutex);
     648                fibril_mutex_lock(&ns->mutex);
    662649               
    663650                cont = ns8250_received(port);
    … …  
    665652                        uint8_t val = ns8250_read_8(port);
    666653                       
    667                         if (data->client_connected) {
    668                                 if (!buf_push_back(&data->input_buffer, val)) {
     654                        if (ns->client_connected) {
     655                                if (!buf_push_back(&ns->input_buffer, val)) {
    669656                                        printf(NAME ": buffer overflow on "
    670                                             "%s.\n", dev->name);
     657                                            "%s.\n", ns->dev->name);
    671658                                } else {
    672659                                        printf(NAME ": the character %c saved "
    673660                                            "to the buffer of %s.\n",
    674                                             val, dev->name);
     661                                            val, ns->dev->name);
    675662                                }
    676663                        }
    677664                }
    678665               
    679                 fibril_mutex_unlock(&data->mutex);
     666                fibril_mutex_unlock(&ns->mutex);
    680667                fibril_yield();
    681668        }
    … …  
    689676 * @param dev           The serial port device.
    690677 */
    691 static inline void ns8250_interrupt_handler(device_t *dev, ipc_callid_t iid,
     678static inline void ns8250_interrupt_handler(ddf_dev_t *dev, ipc_callid_t iid,
    692679    ipc_call_t *icall)
    693680{
    694         ns8250_read_from_device(dev);
     681        ns8250_read_from_device(NS8250_FROM_DEV(dev));
    695682}
    696683
    697684/** Register the interrupt handler for the device.
    698685 *
     686 * @param ns            Serial port device
     687 */
     688static inline int ns8250_register_interrupt_handler(ns8250_t *ns)
     689{
     690        return register_interrupt_handler(ns->dev, ns->irq,
     691            ns8250_interrupt_handler, NULL);
     692}
     693
     694/** Unregister the interrupt handler for the device.
     695 *
     696 * @param ns            Serial port device
     697 */
     698static inline int ns8250_unregister_interrupt_handler(ns8250_t *ns)
     699{
     700        return unregister_interrupt_handler(ns->dev, ns->irq);
     701}
     702
     703/** The add_device callback method of the serial port driver.
     704 *
     705 * Probe and initialize the newly added device.
     706 *
    699707 * @param dev           The serial port device.
    700708 */
    701 static inline int ns8250_register_interrupt_handler(device_t *dev)
    702 {
    703         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    704        
    705         return register_interrupt_handler(dev, data->irq,
    706             ns8250_interrupt_handler, NULL);
    707 }
    708 
    709 /** Unregister the interrupt handler for the device.
    710  *
    711  * @param dev           The serial port device.
    712  */
    713 static inline int ns8250_unregister_interrupt_handler(device_t *dev)
    714 {
    715         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    716        
    717         return unregister_interrupt_handler(dev, data->irq);
    718 }
    719 
    720 /** The add_device callback method of the serial port driver.
    721  *
    722  * Probe and initialize the newly added device.
    723  *
    724  * @param dev           The serial port device.
    725  */
    726 static int ns8250_add_device(device_t *dev)
    727 {
     709static int ns8250_add_device(ddf_dev_t *dev)
     710{
     711        ns8250_t *ns = NULL;
     712        ddf_fun_t *fun = NULL;
     713        bool need_cleanup = false;
     714        int rc;
     715       
    728716        printf(NAME ": ns8250_add_device %s (handle = %d)\n",
    729717            dev->name, (int) dev->handle);
    730718       
    731         int res = ns8250_dev_initialize(dev);
    732         if (res != EOK)
    733                 return res;
    734        
    735         if (!ns8250_pio_enable(dev)) {
    736                 ns8250_dev_cleanup(dev);
    737                 return EADDRNOTAVAIL;
     719        /* Allocate soft-state for the device */
     720        ns = ns8250_new();
     721        if (ns == NULL) {
     722                rc = ENOMEM;
     723                goto fail;
     724        }
     725       
     726        ns->dev = dev;
     727        dev->driver_data = ns;
     728       
     729        rc = ns8250_dev_initialize(ns);
     730        if (rc != EOK)
     731                goto fail;
     732       
     733        need_cleanup = true;
     734       
     735        if (!ns8250_pio_enable(ns)) {
     736                rc = EADDRNOTAVAIL;
     737                goto fail;
    738738        }
    739739       
    740740        /* Find out whether the device is present. */
    741         if (!ns8250_dev_probe(dev)) {
    742                 ns8250_dev_cleanup(dev);
    743                 return ENOENT;
     741        if (!ns8250_dev_probe(ns)) {
     742                rc = ENOENT;
     743                goto fail;
    744744        }
    745745       
    746746        /* Serial port initialization (baud rate etc.). */
    747         ns8250_initialize_port(dev);
     747        ns8250_initialize_port(ns);
    748748       
    749749        /* Register interrupt handler. */
    750         if (ns8250_register_interrupt_handler(dev) != EOK) {
     750        if (ns8250_register_interrupt_handler(ns) != EOK) {
    751751                printf(NAME ": failed to register interrupt handler.\n");
    752                 ns8250_dev_cleanup(dev);
    753                 return res;
     752                rc = EADDRNOTAVAIL;
     753                goto fail;
    754754        }
    755755       
    756756        /* Enable interrupt. */
    757         res = ns8250_interrupt_enable(dev);
    758         if (res != EOK) {
     757        rc = ns8250_interrupt_enable(ns);
     758        if (rc != EOK) {
    759759                printf(NAME ": failed to enable the interrupt. Error code = "
    760                     "%d.\n", res);
    761                 ns8250_dev_cleanup(dev);
    762                 ns8250_unregister_interrupt_handler(dev);
    763                 return res;
     760                    "%d.\n", rc);
     761                goto fail;
     762        }
     763       
     764        fun = ddf_fun_create(dev, fun_exposed, "a");
     765        if (fun == NULL) {
     766                printf(NAME ": error creating function.\n");
     767                goto fail;
    764768        }
    765769       
    766770        /* Set device operations. */
    767         dev->ops = &ns8250_dev_ops;
    768        
    769         add_device_to_class(dev, "serial");
     771        fun->ops = &ns8250_dev_ops;
     772        rc = ddf_fun_bind(fun);
     773        if (rc != EOK) {
     774                printf(NAME ": error binding function.\n");
     775                goto fail;
     776        }
     777
     778        ns->fun = fun;
     779       
     780        ddf_fun_add_to_class(fun, "serial");
    770781       
    771782        printf(NAME ": the %s device has been successfully initialized.\n",
    … …  
    773784       
    774785        return EOK;
     786fail:
     787        if (fun != NULL)
     788                ddf_fun_destroy(fun);
     789        if (need_cleanup)
     790                ns8250_dev_cleanup(ns);
     791        if (ns != NULL)
     792                ns8250_delete(ns);
     793        return rc;
    775794}
    776795
    … …  
    782801 * @param dev           The device.
    783802 */
    784 static int ns8250_open(device_t *dev)
    785 {
    786         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     803static int ns8250_open(ddf_fun_t *fun)
     804{
     805        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
    787806        int res;
    788807       
    … …  
    795814        }
    796815        fibril_mutex_unlock(&data->mutex);
    797 
     816       
    798817        return res;
    799818}
    … …  
    806825 * @param dev           The device.
    807826 */
    808 static void ns8250_close(device_t *dev)
    809 {
    810         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     827static void ns8250_close(ddf_fun_t *fun)
     828{
     829        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
    811830       
    812831        fibril_mutex_lock(&data->mutex);
    … …  
    830849 */
    831850static void
    832 ns8250_get_props(device_t *dev, unsigned int *baud_rate, unsigned int *parity,
     851ns8250_get_props(ddf_dev_t *dev, unsigned int *baud_rate, unsigned int *parity,
    833852    unsigned int *word_length, unsigned int* stop_bits)
    834853{
    835         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     854        ns8250_t *data = (ns8250_t *) dev->driver_data;
    836855        ioport8_t *port = data->port;
    837856       
    … …  
    857876 * @param stop_bits     The number of stop bits to be used.
    858877 */
    859 static int ns8250_set_props(device_t *dev, unsigned int baud_rate,
     878static int ns8250_set_props(ddf_dev_t *dev, unsigned int baud_rate,
    860879    unsigned int parity, unsigned int word_length, unsigned int stop_bits)
    861880{
    … …  
    864883            stop_bits);
    865884       
    866         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     885        ns8250_t *data = (ns8250_t *) dev->driver_data;
    867886        ioport8_t *port = data->port;
    868887        int ret;
    … …  
    884903 * Configure the parameters of the serial communication.
    885904 */
    886 static void ns8250_default_handler(device_t *dev, ipc_callid_t callid,
     905static void ns8250_default_handler(ddf_fun_t *fun, ipc_callid_t callid,
    887906    ipc_call_t *call)
    888907{
    … …  
    893912        switch (method) {
    894913        case SERIAL_GET_COM_PROPS:
    895                 ns8250_get_props(dev, &baud_rate, &parity, &word_length,
     914                ns8250_get_props(fun->dev, &baud_rate, &parity, &word_length,
    896915                    &stop_bits);
    897                 ipc_answer_4(callid, EOK, baud_rate, parity, word_length,
     916                async_answer_4(callid, EOK, baud_rate, parity, word_length,
    898917                    stop_bits);
    899918                break;
    … …  
    904923                word_length = IPC_GET_ARG3(*call);
    905924                stop_bits = IPC_GET_ARG4(*call);
    906                 ret = ns8250_set_props(dev, baud_rate, parity, word_length,
     925                ret = ns8250_set_props(fun->dev, baud_rate, parity, word_length,
    907926                    stop_bits);
    908                 ipc_answer_0(callid, ret);
     927                async_answer_0(callid, ret);
    909928                break;
    910929               
    911930        default:
    912                 ipc_answer_0(callid, ENOTSUP);
     931                async_answer_0(callid, ENOTSUP);
    913932        }
    914933}
    … …  
    924943        ns8250_dev_ops.close = &ns8250_close;
    925944       
    926         ns8250_dev_ops.interfaces[CHAR_DEV_IFACE] = &ns8250_char_iface;
     945        ns8250_dev_ops.interfaces[CHAR_DEV_IFACE] = &ns8250_char_dev_ops;
    927946        ns8250_dev_ops.default_handler = &ns8250_default_handler;
    928947}
    … …  
    932951        printf(NAME ": HelenOS serial port driver\n");
    933952        ns8250_init();
    934         return driver_main(&ns8250_driver);
     953        return ddf_driver_main(&ns8250_driver);
    935954}
    936955
Note: See TracChangeset for help on using the changeset viewer.