Changeset 79ae36dd in mainline for uspace/srv/hw


Ignore:
Timestamp:
2011-06-08T19:01:55Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0eff68e
Parents:
764d71e
Message:

new async framework with integrated exchange tracking

  • strict isolation between low-level IPC and high-level async framework with integrated exchange tracking
    • each IPC connection is represented by an async_sess_t structure
    • each IPC exchange is represented by an async_exch_t structure
    • exchange management is either based on atomic messages (EXCHANGE_ATOMIC), locking (EXCHANGE_SERIALIZE) or connection cloning (EXCHANGE_CLONE)
  • async_obsolete: temporary compatibility layer to keep old async clients working (several pieces of code are currently broken, but only non-essential functionality)
  • IPC_M_PHONE_HANGUP is now method no. 0 (for elegant boolean evaluation)
  • IPC_M_DEBUG_ALL has been renamed to IPC_M_DEBUG
  • IPC_M_PING has been removed (VFS protocol now has VFS_IN_PING)
  • console routines in libc have been rewritten for better abstraction
  • additional use for libc-private header files (FILE structure opaque to the client)
  • various cstyle changes (typos, indentation, missing externs in header files, improved comments, etc.)
Location:
uspace/srv/hw
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r764d71e r79ae36dd  
    4848#include <ipc/adb.h>
    4949#include <async.h>
     50#include <async_obsolete.h>
    5051#include <assert.h>
    5152#include "cuda_adb.h"
     53
     54// FIXME: remove this header
     55#include <kernel/ipc/ipc_methods.h>
    5256
    5357#define NAME "cuda_adb"
    … …  
    219223                callid = async_get_call(&call);
    220224                method = IPC_GET_IMETHOD(call);
    221                 switch (method) {
    222                 case IPC_M_PHONE_HUNGUP:
     225               
     226                if (!method) {
    223227                        /* The other side has hung up. */
    224228                        async_answer_0(callid, EOK);
    225229                        return;
     230                }
     231               
     232                switch (method) {
    226233                case IPC_M_CONNECT_TO_ME:
    227234                        if (adb_dev[dev_addr].client_phone != -1) {
    … …  
    479486                return;
    480487
    481         async_msg_1(adb_dev[dev_addr].client_phone, ADB_REG_NOTIF, reg_val);
     488        async_obsolete_msg_1(adb_dev[dev_addr].client_phone, ADB_REG_NOTIF, reg_val);
    482489}
    483490

  • uspace/srv/hw/char/i8042/i8042.c

    r764d71e r79ae36dd  
    4141#include <devmap.h>
    4242#include <async.h>
     43#include <async_obsolete.h>
    4344#include <unistd.h>
    4445#include <sysinfo.h>
    … …  
    4647#include <errno.h>
    4748#include <inttypes.h>
    48 
    4949#include "i8042.h"
     50
     51// FIXME: remove this header
     52#include <kernel/ipc/ipc_methods.h>
    5053
    5154#define NAME "i8042"
    … …  
    247250                callid = async_get_call(&call);
    248251                method = IPC_GET_IMETHOD(call);
    249                 switch (method) {
    250                 case IPC_M_PHONE_HUNGUP:
     252               
     253                if (!method) {
    251254                        /* The other side has hung up. */
    252255                        async_answer_0(callid, EOK);
    253256                        return;
     257                }
     258               
     259                switch (method) {
    254260                case IPC_M_CONNECT_TO_ME:
    255261                        printf(NAME ": creating callback connection\n");
    … …  
    300306
    301307        if (i8042_port[devid].client_phone != -1) {
    302                 async_msg_1(i8042_port[devid].client_phone,
     308                async_obsolete_msg_1(i8042_port[devid].client_phone,
    303309                    IPC_FIRST_USER_METHOD, data);
    304310        }

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    r764d71e r79ae36dd  
    4242#include <ipc/char.h>
    4343#include <async.h>
     44#include <async_obsolete.h>
    4445#include <unistd.h>
    4546#include <stdio.h>
    … …  
    4849#include <errno.h>
    4950#include <inttypes.h>
    50 
    5151#include "s3c24xx_uart.h"
     52
     53// FIXME: remove this header
     54#include <kernel/ipc/ipc_methods.h>
    5255
    5356#define NAME "s3c24ser"
    … …  
    123126                callid = async_get_call(&call);
    124127                method = IPC_GET_IMETHOD(call);
    125                 switch (method) {
    126                 case IPC_M_PHONE_HUNGUP:
     128               
     129                if (!method) {
    127130                        /* The other side has hung up. */
    128131                        async_answer_0(callid, EOK);
    129132                        return;
     133                }
     134               
     135                switch (method) {
    130136                case IPC_M_CONNECT_TO_ME:
    131137                        printf(NAME ": creating callback connection\n");
    … …  
    156162
    157163                if (uart->client_phone != -1) {
    158                         async_msg_1(uart->client_phone, CHAR_NOTIF_BYTE,
     164                        async_obsolete_msg_1(uart->client_phone, CHAR_NOTIF_BYTE,
    159165                            data);
    160166                }

  • uspace/srv/hw/irc/apic/apic.c

    r764d71e r79ae36dd  
    3838#include <ipc/services.h>
    3939#include <ipc/irc.h>
    40 #include <ipc/ns.h>
     40#include <ns.h>
    4141#include <sysinfo.h>
    4242#include <as.h>
    … …  
    7979                callid = async_get_call(&call);
    8080               
     81                if (!IPC_GET_IMETHOD(call)) {
     82                        /* The other side has hung up. */
     83                        async_answer_0(callid, EOK);
     84                        return;
     85                }
     86               
    8187                switch (IPC_GET_IMETHOD(call)) {
    8288                case IRC_ENABLE_INTERRUPT:
    … …  
    8793                        async_answer_0(callid, EOK);
    8894                        break;
    89                 case IPC_M_PHONE_HUNGUP:
    90                         /* The other side has hung up. */
    91                         async_answer_0(callid, EOK);
    92                         return;
    9395                default:
    9496                        async_answer_0(callid, EINVAL);
    … …  
    106108       
    107109        if ((sysinfo_get_value("apic", &apic) != EOK) || (!apic)) {
    108                 printf(NAME ": No APIC found\n");
     110                printf("%s: No APIC found\n", NAME);
    109111                return false;
    110112        }
    … …  
    118120int main(int argc, char **argv)
    119121{
    120         printf(NAME ": HelenOS APIC driver\n");
     122        printf("%s: HelenOS APIC driver\n", NAME);
    121123       
    122124        if (!apic_init())
    123125                return -1;
    124126       
    125         printf(NAME ": Accepting connections\n");
     127        printf("%s: Accepting connections\n", NAME);
     128        task_retval(0);
    126129        async_manager();
    127130       

  • uspace/srv/hw/irc/fhc/fhc.c

    r764d71e r79ae36dd  
    3838#include <ipc/services.h>
    3939#include <ipc/irc.h>
    40 #include <ipc/ns.h>
     40#include <ns.h>
    4141#include <sysinfo.h>
    4242#include <as.h>
    … …  
    5353#define NAME "fhc"
    5454
    55 #define FHC_UART_INR    0x39   
     55#define FHC_UART_INR    0x39
    5656
    5757#define FHC_UART_IMAP   0x0
    … …  
    128128       
    129129        if (retval < 0) {
    130                 printf(NAME ": Error mapping FHC UART registers\n");
     130                printf("%s: Error mapping FHC UART registers\n", NAME);
    131131                return false;
    132132        }
    133133       
    134         printf(NAME ": FHC UART registers at %p, %zu bytes\n", fhc_uart_phys,
    135             fhc_uart_size);
     134        printf("%s: FHC UART registers at %p, %zu bytes\n", NAME,
     135            fhc_uart_phys, fhc_uart_size);
    136136       
    137137        async_set_client_connection(fhc_connection);
    … …  
    143143int main(int argc, char **argv)
    144144{
    145         printf(NAME ": HelenOS FHC bus controller driver\n");
     145        printf("%s: HelenOS FHC bus controller driver\n", NAME);
    146146       
    147147        if (!fhc_init())
    148148                return -1;
    149149       
    150         printf(NAME ": Accepting connections\n");
     150        printf("%s: Accepting connections\n", NAME);
     151        task_retval(0);
    151152        async_manager();
    152 
     153       
    153154        /* Never reached */
    154155        return 0;
    … …  
    157158/**
    158159 * @}
    159  */ 
     160 */

  • uspace/srv/hw/irc/i8259/i8259.c

    r764d71e r79ae36dd  
    3838#include <ipc/services.h>
    3939#include <ipc/irc.h>
    40 #include <ipc/ns.h>
     40#include <ns.h>
    4141#include <sysinfo.h>
    4242#include <as.h>
    … …  
    113113                callid = async_get_call(&call);
    114114               
     115                if (!IPC_GET_IMETHOD(call)) {
     116                        /* The other side has hung up. */
     117                        async_answer_0(callid, EOK);
     118                        return;
     119                }
     120               
    115121                switch (IPC_GET_IMETHOD(call)) {
    116122                case IRC_ENABLE_INTERRUPT:
    … …  
    121127                        async_answer_0(callid, EOK);
    122128                        break;
    123                 case IPC_M_PHONE_HUNGUP:
    124                         /* The other side has hung up. */
    125                         async_answer_0(callid, EOK);
    126                         return;
    127129                default:
    128130                        async_answer_0(callid, EINVAL);
    … …  
    140142       
    141143        if ((sysinfo_get_value("i8259", &i8259) != EOK) || (!i8259)) {
    142                 printf(NAME ": No i8259 found\n");
     144                printf("%s: No i8259 found\n", NAME);
    143145                return false;
    144146        }
    … …  
    148150            (pio_enable((void *) IO_RANGE1_START, IO_RANGE1_SIZE,
    149151            (void **) &io_range1) != EOK)) {
    150                 printf(NAME ": i8259 not accessible\n");
     152                printf("%s: i8259 not accessible\n", NAME);
    151153                return false;
    152154        }
    … …  
    160162int main(int argc, char **argv)
    161163{
    162         printf(NAME ": HelenOS i8259 driver\n");
     164        printf("%s: HelenOS i8259 driver\n", NAME);
    163165       
    164166        if (!i8259_init())
    165167                return -1;
    166168       
    167         printf(NAME ": Accepting connections\n");
     169        printf("%s: Accepting connections\n", NAME);
     170        task_retval(0);
    168171        async_manager();
    169172       

  • uspace/srv/hw/irc/obio/obio.c

    r764d71e r79ae36dd  
    4444#include <ipc/services.h>
    4545#include <ipc/irc.h>
    46 #include <ipc/ns.h>
     46#include <ns.h>
    4747#include <sysinfo.h>
    4848#include <as.h>
    … …  
    118118       
    119119        if (sysinfo_get_value("obio.base.physical", &paddr) != EOK) {
    120                 printf(NAME ": no OBIO registers found\n");
     120                printf("%s: No OBIO registers found\n", NAME);
    121121                return false;
    122122        }
    … …  
    130130       
    131131        if (retval < 0) {
    132                 printf(NAME ": Error mapping OBIO registers\n");
     132                printf("%s: Error mapping OBIO registers\n", NAME);
    133133                return false;
    134134        }
    135135       
    136         printf(NAME ": OBIO registers with base at %p\n", base_phys);
     136        printf("%s: OBIO registers with base at %p\n", NAME, base_phys);
    137137       
    138138        async_set_client_connection(obio_connection);
    … …  
    144144int main(int argc, char **argv)
    145145{
    146         printf(NAME ": HelenOS OBIO driver\n");
     146        printf("%s: HelenOS OBIO driver\n", NAME);
    147147       
    148148        if (!obio_init())
    149149                return -1;
    150150       
    151         printf(NAME ": Accepting connections\n");
     151        printf("%s: Accepting connections\n", NAME);
     152        task_retval(0);
    152153        async_manager();
    153 
     154       
    154155        /* Never reached */
    155156        return 0;
    … …  
    158159/**
    159160 * @}
    160  */ 
     161 */

  • uspace/srv/hw/netif/ne2000/ne2000.c

    r764d71e r79ae36dd  
    3838#include <assert.h>
    3939#include <async.h>
     40#include <async_obsolete.h>
    4041#include <ddi.h>
    4142#include <errno.h>
    … …  
    4445#include <sysinfo.h>
    4546#include <ipc/services.h>
    46 #include <ipc/ns.h>
     47#include <ns.h>
     48#include <ns_obsolete.h>
    4749#include <ipc/irc.h>
    4850#include <net/modules.h>
    … …  
    330332               
    331333                if (irc_service)
    332                         async_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, ne2k->irq);
     334                        async_obsolete_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, ne2k->irq);
    333335        }
    334336       
    … …  
    389391        if (irc_service) {
    390392                while (irc_phone < 0)
    391                         irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
     393                        irc_phone = service_obsolete_connect_blocking(SERVICE_IRC, 0, 0);
    392394        }
    393395       
    394396        async_set_interrupt_received(irq_handler);
    395397       
    396         return async_connect_to_me(PHONE_NS, SERVICE_NE2000, 0, 0, NULL);
     398        return service_register(SERVICE_NE2000);
    397399}
    398400
Note: See TracChangeset for help on using the changeset viewer.