Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ns8250/ns8250.c

    r77429d3 rebcb05a  
    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 <ddf/driver.h>
     56#include <ddf/interrupt.h>
     57#include <ddf/log.h>
    5558#include <ops/char_dev.h>
    5659
    … …  
    6770#define MAX_BAUD_RATE 115200
    6871#define DLAB_MASK (1 << 7)
     72
     73/** Obtain soft-state structure from function node */
     74#define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
     75
     76/** Obtain soft-state structure from device node */
     77#define NS8250_FROM_DEV(dnode) ((ns8250_t *) ((dnode)->driver_data))
    6978
    7079/** The number of bits of one data unit send by the serial port. */
    … …  
    8594
    8695/** The driver data for the serial port devices. */
    87 typedef struct ns8250_dev_data {
     96typedef struct ns8250 {
     97        /** DDF device node */
     98        ddf_dev_t *dev;
     99        /** DDF function node */
     100        ddf_fun_t *fun;
    88101        /** Is there any client conntected to the device? */
    89102        bool client_connected;
    … …  
    98111        /** The fibril mutex for synchronizing the access to the device. */
    99112        fibril_mutex_t mutex;
    100 } ns8250_dev_data_t;
    101 
    102 /** Create driver data for a device.
    103  *
    104  * @return              The driver data.
    105  */
    106 static ns8250_dev_data_t *create_ns8250_dev_data(void)
    107 {
    108         ns8250_dev_data_t *data;
    109        
    110         data = (ns8250_dev_data_t *) malloc(sizeof(ns8250_dev_data_t));
    111         if (NULL != data) {
    112                 memset(data, 0, sizeof(ns8250_dev_data_t));
    113                 fibril_mutex_initialize(&data->mutex);
    114         }
    115         return data;
    116 }
    117 
    118 /** Delete driver data.
    119  *
    120  * @param data          The driver data structure.
    121  */
    122 static void delete_ns8250_dev_data(ns8250_dev_data_t *data)
    123 {
    124         if (data != NULL)
    125                 free(data);
     113} ns8250_t;
     114
     115/** Create per-device soft-state structure.
     116 *
     117 * @return      Pointer to soft-state structure.
     118 */
     119static ns8250_t *ns8250_new(void)
     120{
     121        ns8250_t *ns;
     122       
     123        ns = (ns8250_t *) calloc(1, sizeof(ns8250_t));
     124        if (ns == NULL)
     125                return NULL;
     126       
     127        fibril_mutex_initialize(&ns->mutex);
     128        return ns;
     129}
     130
     131/** Delete soft-state structure.
     132 *
     133 * @param ns    The driver data structure.
     134 */
     135static void ns8250_delete(ns8250_t *ns)
     136{
     137        assert(ns != NULL);
     138        free(ns);
    126139}
    127140
    … …  
    171184/** Read data from the serial port device.
    172185 *
    173  * @param dev           The serial port device.
     186 * @param fun           The serial port function
    174187 * @param buf           The ouput buffer for read data.
    175188 * @param count         The number of bytes to be read.
    … …  
    178191 *                      error number otherwise.
    179192 */
    180 static int ns8250_read(device_t *dev, char *buf, size_t count)
    181 {
     193static int ns8250_read(ddf_fun_t *fun, char *buf, size_t count)
     194{
     195        ns8250_t *ns = NS8250(fun);
    182196        int ret = EOK;
    183         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    184        
    185         fibril_mutex_lock(&data->mutex);
    186         while (!buf_is_empty(&data->input_buffer) && (size_t)ret < count) {
    187                 buf[ret] = (char)buf_pop_front(&data->input_buffer);
     197       
     198        fibril_mutex_lock(&ns->mutex);
     199        while (!buf_is_empty(&ns->input_buffer) && (size_t)ret < count) {
     200                buf[ret] = (char)buf_pop_front(&ns->input_buffer);
    188201                ret++;
    189202        }
    190         fibril_mutex_unlock(&data->mutex);
     203        fibril_mutex_unlock(&ns->mutex);
    191204       
    192205        return ret;
    … …  
    195208/** Write a character to the serial port.
    196209 *
    197  * @param data          The serial port device's driver data.
    198  * @param c             The character to be written.
    199  */
    200 static inline void ns8250_putchar(ns8250_dev_data_t *data, uint8_t c)
    201 {
    202         fibril_mutex_lock(&data->mutex);
    203         ns8250_write_8(data->port, c);
    204         fibril_mutex_unlock(&data->mutex);
     210 * @param ns            Serial port device
     211 * @param c             The character to be written
     212 */
     213static inline void ns8250_putchar(ns8250_t *ns, uint8_t c)
     214{
     215        fibril_mutex_lock(&ns->mutex);
     216        ns8250_write_8(ns->port, c);
     217        fibril_mutex_unlock(&ns->mutex);
    205218}
    206219
    207220/** Write data to the serial port.
    208221 *
    209  * @param dev           The serial port device.
    210  * @param buf           The data to be written.
    211  * @param count         The number of bytes to be written.
    212  * @return              Zero on success.
    213  */
    214 static int ns8250_write(device_t *dev, char *buf, size_t count)
    215 {
    216         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     222 * @param fun           The serial port function
     223 * @param buf           The data to be written
     224 * @param count         The number of bytes to be written
     225 * @return              Zero on success
     226 */
     227static int ns8250_write(ddf_fun_t *fun, char *buf, size_t count)
     228{
     229        ns8250_t *ns = NS8250(fun);
    217230        size_t idx;
    218231       
    219232        for (idx = 0; idx < count; idx++)
    220                 ns8250_putchar(data, (uint8_t) buf[idx]);
     233                ns8250_putchar(ns, (uint8_t) buf[idx]);
    221234       
    222235        return 0;
    223236}
    224237
    225 static device_ops_t ns8250_dev_ops;
     238static ddf_dev_ops_t ns8250_dev_ops;
    226239
    227240/** The character interface's callbacks. */
    … …  
    231244};
    232245
    233 static int ns8250_add_device(device_t *dev);
     246static int ns8250_add_device(ddf_dev_t *dev);
    234247
    235248/** The serial port device driver's standard operations. */
    … …  
    244257};
    245258
    246 /** Clean up the serial port device structure.
    247  *
    248  * @param dev           The device structure.
    249  */
    250 static void ns8250_dev_cleanup(device_t *dev)
    251 {
    252         if (dev->driver_data != NULL) {
    253                 delete_ns8250_dev_data((ns8250_dev_data_t*) dev->driver_data);
    254                 dev->driver_data = NULL;
    255         }
    256        
    257         if (dev->parent_phone > 0) {
    258                 ipc_hangup(dev->parent_phone);
    259                 dev->parent_phone = 0;
     259/** Clean up the serial port soft-state
     260 *
     261 * @param ns            Serial port device
     262 */
     263static void ns8250_dev_cleanup(ns8250_t *ns)
     264{
     265        if (ns->dev->parent_phone > 0) {
     266                async_hangup(ns->dev->parent_phone);
     267                ns->dev->parent_phone = 0;
    260268        }
    261269}
    … …  
    263271/** Enable the i/o ports of the device.
    264272 *
    265  * @param dev           The serial port device.
    266  * @return              True on success, false otherwise.
    267  */
    268 static bool ns8250_pio_enable(device_t *dev)
    269 {
    270         printf(NAME ": ns8250_pio_enable %s\n", dev->name);
    271        
    272         ns8250_dev_data_t *data = (ns8250_dev_data_t *)dev->driver_data;
     273 * @param ns            Serial port device
     274 * @return              True on success, false otherwise
     275 */
     276static bool ns8250_pio_enable(ns8250_t *ns)
     277{
     278        ddf_msg(LVL_DEBUG, "ns8250_pio_enable %s", ns->dev->name);
    273279       
    274280        /* Gain control over port's registers. */
    275         if (pio_enable((void *)(uintptr_t) data->io_addr, REG_COUNT,
    276             (void **) &data->port)) {
    277                 printf(NAME ": error - cannot gain the port %#" PRIx32 " for device "
    278                     "%s.\n", data->io_addr, dev->name);
     281        if (pio_enable((void *)(uintptr_t) ns->io_addr, REG_COUNT,
     282            (void **) &ns->port)) {
     283                ddf_msg(LVL_ERROR, "Cannot map the port %#" PRIx32
     284                    " for device %s.", ns->io_addr, ns->dev->name);
    279285                return false;
    280286        }
    … …  
    285291/** Probe the serial port device for its presence.
    286292 *
    287  * @param dev           The serial port device.
    288  * @return              True if the device is present, false otherwise.
    289  */
    290 static bool ns8250_dev_probe(device_t *dev)
    291 {
    292         printf(NAME ": ns8250_dev_probe %s\n", dev->name);
    293        
    294         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    295         ioport8_t *port_addr = data->port;
     293 * @param ns            Serial port device
     294 * @return              True if the device is present, false otherwise
     295 */
     296static bool ns8250_dev_probe(ns8250_t *ns)
     297{
     298        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
     299       
     300        ioport8_t *port_addr = ns->port;
    296301        bool res = true;
    297302        uint8_t olddata;
    … …  
    309314        pio_write_8(port_addr + 4, olddata);
    310315       
    311         if (!res)
    312                 printf(NAME ": device %s is not present.\n", dev->name);
     316        if (!res) {
     317                ddf_msg(LVL_DEBUG, "Device %s is not present.",
     318                    ns->dev->name);
     319        }
    313320       
    314321        return res;
    … …  
    317324/** Initialize serial port device.
    318325 *
    319  * @param dev           The serial port device.
    320  * @return              Zero on success, negative error number otherwise.
    321  */
    322 static int ns8250_dev_initialize(device_t *dev)
    323 {
    324         printf(NAME ": ns8250_dev_initialize %s\n", dev->name);
     326 * @param ns            Serial port device
     327 * @return              Zero on success, negative error number otherwise
     328 */
     329static int ns8250_dev_initialize(ns8250_t *ns)
     330{
     331        ddf_msg(LVL_DEBUG, "ns8250_dev_initialize %s", ns->dev->name);
    325332       
    326333        int ret = EOK;
    … …  
    329336        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    330337       
    331         /* Allocate driver data for the device. */
    332         ns8250_dev_data_t *data = create_ns8250_dev_data();
    333         if (data == NULL)
    334                 return ENOMEM;
    335         dev->driver_data = data;
    336        
    337338        /* Connect to the parent's driver. */
    338         dev->parent_phone = devman_parent_device_connect(dev->handle,
     339        ns->dev->parent_phone = devman_parent_device_connect(ns->dev->handle,
    339340            IPC_FLAG_BLOCKING);
    340         if (dev->parent_phone < 0) {
    341                 printf(NAME ": failed to connect to the parent driver of the "
    342                     "device %s.\n", dev->name);
    343                 ret = dev->parent_phone;
     341        if (ns->dev->parent_phone < 0) {
     342                ddf_msg(LVL_ERROR, "Failed to connect to parent driver of "
     343                    "device %s.", ns->dev->name);
     344                ret = ns->dev->parent_phone;
    344345                goto failed;
    345346        }
    346347       
    347348        /* Get hw resources. */
    348         ret = hw_res_get_resource_list(dev->parent_phone, &hw_resources);
     349        ret = hw_res_get_resource_list(ns->dev->parent_phone, &hw_resources);
    349350        if (ret != EOK) {
    350                 printf(NAME ": failed to get hw resources for the device "
    351                     "%s.\n", dev->name);
     351                ddf_msg(LVL_ERROR, "Failed to get HW resources for device "
     352                    "%s.", ns->dev->name);
    352353                goto failed;
    353354        }
    … …  
    362363                switch (res->type) {
    363364                case INTERRUPT:
    364                         data->irq = res->res.interrupt.irq;
     365                        ns->irq = res->res.interrupt.irq;
    365366                        irq = true;
    366                         printf(NAME ": the %s device was asigned irq = 0x%x.\n",
    367                             dev->name, data->irq);
     367                        ddf_msg(LVL_NOTE, "Device %s was asigned irq = 0x%x.",
     368                            ns->dev->name, ns->irq);
    368369                        break;
    369370                       
    370371                case IO_RANGE:
    371                         data->io_addr = res->res.io_range.address;
     372                        ns->io_addr = res->res.io_range.address;
    372373                        if (res->res.io_range.size < REG_COUNT) {
    373                                 printf(NAME ": i/o range assigned to the device "
    374                                     "%s is too small.\n", dev->name);
     374                                ddf_msg(LVL_ERROR, "I/O range assigned to "
     375                                    "device %s is too small.", ns->dev->name);
    375376                                ret = ELIMIT;
    376377                                goto failed;
    377378                        }
    378379                        ioport = true;
    379                         printf(NAME ": the %s device was asigned i/o address = "
    380                             "0x%x.\n", dev->name, data->io_addr);
    381                         break;
     380                        ddf_msg(LVL_NOTE, "Device %s was asigned I/O address = "
     381                            "0x%x.", ns->dev->name, ns->io_addr);
     382                        break;
    382383                       
    383384                default:
    … …  
    387388       
    388389        if (!irq || !ioport) {
    389                 printf(NAME ": missing hw resource(s) for the device %s.\n",
    390                     dev->name);
     390                ddf_msg(LVL_ERROR, "Missing HW resource(s) for device %s.",
     391                    ns->dev->name);
    391392                ret = ENOENT;
    392393                goto failed;
    … …  
    397398       
    398399failed:
    399         ns8250_dev_cleanup(dev);
     400        ns8250_dev_cleanup(ns);
    400401        hw_res_clean_resource_list(&hw_resources);
    401402        return ret;
    … …  
    404405/** Enable interrupts on the serial port device.
    405406 *
    406  * Interrupt when data is received.
     407 * Interrupt when data is received
    407408 *
    408409 * @param port          The base address of the serial port device's ports.
    409410 */
    410411static inline void ns8250_port_interrupts_enable(ioport8_t *port)
    411 {       
     412{
    412413        pio_write_8(port + 1, 0x1);     /* Interrupt when data received. */
    413414        pio_write_8(port + 4, 0xB);
    … …  
    416417/** Disable interrupts on the serial port device.
    417418 *
    418  * @param port          The base address of the serial port device's ports.
     419 * @param port          The base address of the serial port device's ports
    419420 */
    420421static inline void ns8250_port_interrupts_disable(ioport8_t *port)
    … …  
    425426/** Enable interrupts for the serial port device.
    426427 *
    427  * @param dev           The device.
    428  * @return              Zero on success, negative error number otherwise.
    429  */
    430 static int ns8250_interrupt_enable(device_t *dev)
    431 {
    432         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    433        
     428 * @param ns            Serial port device
     429 * @return              Zero on success, negative error number otherwise
     430 */
     431static int ns8250_interrupt_enable(ns8250_t *ns)
     432{
    434433        /* Enable interrupt on the serial port. */
    435         ns8250_port_interrupts_enable(data->port);
     434        ns8250_port_interrupts_enable(ns->port);
    436435       
    437436        return EOK;
    … …  
    474473       
    475474        if (baud_rate < 50 || MAX_BAUD_RATE % baud_rate != 0) {
    476                 printf(NAME ": error - somebody tried to set invalid baud rate "
    477                     "%d\n", baud_rate);
     475                ddf_msg(LVL_ERROR, "Invalid baud rate %d requested.",
     476                    baud_rate);
    478477                return EINVAL;
    479478        }
    … …  
    618617 * Set the default parameters of the serial communication.
    619618 *
    620  * @param dev           The serial port device.
    621  */
    622 static void ns8250_initialize_port(device_t *dev)
    623 {
    624         ns8250_dev_data_t *data = (ns8250_dev_data_t *)dev->driver_data;
    625         ioport8_t *port = data->port;
     619 * @param ns            Serial port device
     620 */
     621static void ns8250_initialize_port(ns8250_t *ns)
     622{
     623        ioport8_t *port = ns->port;
    626624       
    627625        /* Disable interrupts. */
    … …  
    643641 * buffer.
    644642 *
    645  * @param dev           The serial port device.
    646  */
    647 static void ns8250_read_from_device(device_t *dev)
    648 {
    649         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    650         ioport8_t *port = data->port;
     643 * @param ns            Serial port device
     644 */
     645static void ns8250_read_from_device(ns8250_t *ns)
     646{
     647        ioport8_t *port = ns->port;
    651648        bool cont = true;
    652649       
    653650        while (cont) {
    654                 fibril_mutex_lock(&data->mutex);
     651                fibril_mutex_lock(&ns->mutex);
    655652               
    656653                cont = ns8250_received(port);
    … …  
    658655                        uint8_t val = ns8250_read_8(port);
    659656                       
    660                         if (data->client_connected) {
    661                                 if (!buf_push_back(&data->input_buffer, val)) {
    662                                         printf(NAME ": buffer overflow on "
    663                                             "%s.\n", dev->name);
     657                        if (ns->client_connected) {
     658                                if (!buf_push_back(&ns->input_buffer, val)) {
     659                                        ddf_msg(LVL_WARN, "Buffer overflow on "
     660                                            "%s.", ns->dev->name);
    664661                                } else {
    665                                         printf(NAME ": the character %c saved "
    666                                             "to the buffer of %s.\n",
    667                                             val, dev->name);
     662                                        ddf_msg(LVL_DEBUG2, "Character %c saved "
     663                                            "to the buffer of %s.",
     664                                            val, ns->dev->name);
    668665                                }
    669666                        }
    670667                }
    671668               
    672                 fibril_mutex_unlock(&data->mutex);
     669                fibril_mutex_unlock(&ns->mutex);
    673670                fibril_yield();
    674671        }
    … …  
    682679 * @param dev           The serial port device.
    683680 */
    684 static inline void ns8250_interrupt_handler(device_t *dev, ipc_callid_t iid,
     681static inline void ns8250_interrupt_handler(ddf_dev_t *dev, ipc_callid_t iid,
    685682    ipc_call_t *icall)
    686683{
    687         ns8250_read_from_device(dev);
     684        ns8250_read_from_device(NS8250_FROM_DEV(dev));
    688685}
    689686
    690687/** Register the interrupt handler for the device.
    691688 *
     689 * @param ns            Serial port device
     690 */
     691static inline int ns8250_register_interrupt_handler(ns8250_t *ns)
     692{
     693        return register_interrupt_handler(ns->dev, ns->irq,
     694            ns8250_interrupt_handler, NULL);
     695}
     696
     697/** Unregister the interrupt handler for the device.
     698 *
     699 * @param ns            Serial port device
     700 */
     701static inline int ns8250_unregister_interrupt_handler(ns8250_t *ns)
     702{
     703        return unregister_interrupt_handler(ns->dev, ns->irq);
     704}
     705
     706/** The add_device callback method of the serial port driver.
     707 *
     708 * Probe and initialize the newly added device.
     709 *
    692710 * @param dev           The serial port device.
    693711 */
    694 static inline int ns8250_register_interrupt_handler(device_t *dev)
    695 {
    696         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    697        
    698         return register_interrupt_handler(dev, data->irq,
    699             ns8250_interrupt_handler, NULL);
    700 }
    701 
    702 /** Unregister the interrupt handler for the device.
    703  *
    704  * @param dev           The serial port device.
    705  */
    706 static inline int ns8250_unregister_interrupt_handler(device_t *dev)
    707 {
    708         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
    709        
    710         return unregister_interrupt_handler(dev, data->irq);
    711 }
    712 
    713 /** The add_device callback method of the serial port driver.
    714  *
    715  * Probe and initialize the newly added device.
    716  *
    717  * @param dev           The serial port device.
    718  */
    719 static int ns8250_add_device(device_t *dev)
    720 {
    721         printf(NAME ": ns8250_add_device %s (handle = %d)\n",
     712static int ns8250_add_device(ddf_dev_t *dev)
     713{
     714        ns8250_t *ns = NULL;
     715        ddf_fun_t *fun = NULL;
     716        bool need_cleanup = false;
     717        int rc;
     718       
     719        ddf_msg(LVL_DEBUG, "ns8250_add_device %s (handle = %d)",
    722720            dev->name, (int) dev->handle);
    723721       
    724         int res = ns8250_dev_initialize(dev);
    725         if (res != EOK)
    726                 return res;
    727        
    728         if (!ns8250_pio_enable(dev)) {
    729                 ns8250_dev_cleanup(dev);
    730                 return EADDRNOTAVAIL;
     722        /* Allocate soft-state for the device */
     723        ns = ns8250_new();
     724        if (ns == NULL) {
     725                rc = ENOMEM;
     726                goto fail;
     727        }
     728       
     729        ns->dev = dev;
     730        dev->driver_data = ns;
     731       
     732        rc = ns8250_dev_initialize(ns);
     733        if (rc != EOK)
     734                goto fail;
     735       
     736        need_cleanup = true;
     737       
     738        if (!ns8250_pio_enable(ns)) {
     739                rc = EADDRNOTAVAIL;
     740                goto fail;
    731741        }
    732742       
    733743        /* Find out whether the device is present. */
    734         if (!ns8250_dev_probe(dev)) {
    735                 ns8250_dev_cleanup(dev);
    736                 return ENOENT;
     744        if (!ns8250_dev_probe(ns)) {
     745                rc = ENOENT;
     746                goto fail;
    737747        }
    738748       
    739749        /* Serial port initialization (baud rate etc.). */
    740         ns8250_initialize_port(dev);
     750        ns8250_initialize_port(ns);
    741751       
    742752        /* Register interrupt handler. */
    743         if (ns8250_register_interrupt_handler(dev) != EOK) {
    744                 printf(NAME ": failed to register interrupt handler.\n");
    745                 ns8250_dev_cleanup(dev);
    746                 return res;
     753        if (ns8250_register_interrupt_handler(ns) != EOK) {
     754                ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
     755                rc = EADDRNOTAVAIL;
     756                goto fail;
    747757        }
    748758       
    749759        /* Enable interrupt. */
    750         res = ns8250_interrupt_enable(dev);
    751         if (res != EOK) {
    752                 printf(NAME ": failed to enable the interrupt. Error code = "
    753                     "%d.\n", res);
    754                 ns8250_dev_cleanup(dev);
    755                 ns8250_unregister_interrupt_handler(dev);
    756                 return res;
     760        rc = ns8250_interrupt_enable(ns);
     761        if (rc != EOK) {
     762                ddf_msg(LVL_ERROR, "Failed to enable the interrupt. Error code = "
     763                    "%d.", rc);
     764                goto fail;
     765        }
     766       
     767        fun = ddf_fun_create(dev, fun_exposed, "a");
     768        if (fun == NULL) {
     769                ddf_msg(LVL_ERROR, "Failed creating function.");
     770                goto fail;
    757771        }
    758772       
    759773        /* Set device operations. */
    760         dev->ops = &ns8250_dev_ops;
    761        
    762         add_device_to_class(dev, "serial");
    763        
    764         printf(NAME ": the %s device has been successfully initialized.\n",
     774        fun->ops = &ns8250_dev_ops;
     775        rc = ddf_fun_bind(fun);
     776        if (rc != EOK) {
     777                ddf_msg(LVL_ERROR, "Failed binding function.");
     778                goto fail;
     779        }
     780
     781        ns->fun = fun;
     782       
     783        ddf_fun_add_to_class(fun, "serial");
     784       
     785        ddf_msg(LVL_NOTE, "Device %s successfully initialized.",
    765786            dev->name);
    766787       
    767788        return EOK;
     789fail:
     790        if (fun != NULL)
     791                ddf_fun_destroy(fun);
     792        if (need_cleanup)
     793                ns8250_dev_cleanup(ns);
     794        if (ns != NULL)
     795                ns8250_delete(ns);
     796        return rc;
    768797}
    769798
    … …  
    775804 * @param dev           The device.
    776805 */
    777 static int ns8250_open(device_t *dev)
    778 {
    779         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     806static int ns8250_open(ddf_fun_t *fun)
     807{
     808        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
    780809        int res;
    781810       
    … …  
    788817        }
    789818        fibril_mutex_unlock(&data->mutex);
    790 
     819       
    791820        return res;
    792821}
    … …  
    799828 * @param dev           The device.
    800829 */
    801 static void ns8250_close(device_t *dev)
    802 {
    803         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     830static void ns8250_close(ddf_fun_t *fun)
     831{
     832        ns8250_t *data = (ns8250_t *) fun->dev->driver_data;
    804833       
    805834        fibril_mutex_lock(&data->mutex);
    … …  
    823852 */
    824853static void
    825 ns8250_get_props(device_t *dev, unsigned int *baud_rate, unsigned int *parity,
     854ns8250_get_props(ddf_dev_t *dev, unsigned int *baud_rate, unsigned int *parity,
    826855    unsigned int *word_length, unsigned int* stop_bits)
    827856{
    828         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     857        ns8250_t *data = (ns8250_t *) dev->driver_data;
    829858        ioport8_t *port = data->port;
    830859       
    … …  
    836865        fibril_mutex_unlock(&data->mutex);
    837866       
    838         printf(NAME ": ns8250_get_props: baud rate %d, parity 0x%x, word "
    839             "length %d, stop bits %d\n", *baud_rate, *parity, *word_length,
     867        ddf_msg(LVL_DEBUG, "ns8250_get_props: baud rate %d, parity 0x%x, word "
     868            "length %d, stop bits %d", *baud_rate, *parity, *word_length,
    840869            *stop_bits);
    841870}
    … …  
    850879 * @param stop_bits     The number of stop bits to be used.
    851880 */
    852 static int ns8250_set_props(device_t *dev, unsigned int baud_rate,
     881static int ns8250_set_props(ddf_dev_t *dev, unsigned int baud_rate,
    853882    unsigned int parity, unsigned int word_length, unsigned int stop_bits)
    854883{
    855         printf(NAME ": ns8250_set_props: baud rate %d, parity 0x%x, word "
    856             "length %d, stop bits %d\n", baud_rate, parity, word_length,
     884        ddf_msg(LVL_DEBUG, "ns8250_set_props: baud rate %d, parity 0x%x, word "
     885            "length %d, stop bits %d", baud_rate, parity, word_length,
    857886            stop_bits);
    858887       
    859         ns8250_dev_data_t *data = (ns8250_dev_data_t *) dev->driver_data;
     888        ns8250_t *data = (ns8250_t *) dev->driver_data;
    860889        ioport8_t *port = data->port;
    861890        int ret;
    … …  
    877906 * Configure the parameters of the serial communication.
    878907 */
    879 static void ns8250_default_handler(device_t *dev, ipc_callid_t callid,
     908static void ns8250_default_handler(ddf_fun_t *fun, ipc_callid_t callid,
    880909    ipc_call_t *call)
    881910{
    … …  
    886915        switch (method) {
    887916        case SERIAL_GET_COM_PROPS:
    888                 ns8250_get_props(dev, &baud_rate, &parity, &word_length,
     917                ns8250_get_props(fun->dev, &baud_rate, &parity, &word_length,
    889918                    &stop_bits);
    890                 ipc_answer_4(callid, EOK, baud_rate, parity, word_length,
     919                async_answer_4(callid, EOK, baud_rate, parity, word_length,
    891920                    stop_bits);
    892921                break;
    … …  
    897926                word_length = IPC_GET_ARG3(*call);
    898927                stop_bits = IPC_GET_ARG4(*call);
    899                 ret = ns8250_set_props(dev, baud_rate, parity, word_length,
     928                ret = ns8250_set_props(fun->dev, baud_rate, parity, word_length,
    900929                    stop_bits);
    901                 ipc_answer_0(callid, ret);
     930                async_answer_0(callid, ret);
    902931                break;
    903932               
    904933        default:
    905                 ipc_answer_0(callid, ENOTSUP);
     934                async_answer_0(callid, ENOTSUP);
    906935        }
    907936}
    … …  
    914943static void ns8250_init(void)
    915944{
     945        ddf_log_init(NAME, LVL_ERROR);
     946       
    916947        ns8250_dev_ops.open = &ns8250_open;
    917948        ns8250_dev_ops.close = &ns8250_close;
    … …  
    925956        printf(NAME ": HelenOS serial port driver\n");
    926957        ns8250_init();
    927         return driver_main(&ns8250_driver);
     958        return ddf_driver_main(&ns8250_driver);
    928959}
    929960
Note: See TracChangeset for help on using the changeset viewer.