Changeset cb41a5e in mainline for uspace/lib/libc/generic/devmap.c


Ignore:
Timestamp:
2009-05-21T07:03:38Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a095d20
Parents:
2246de6
Message:

improve devmap interface
remove spared device

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/libc/generic/devmap.c

    r2246de6 rcb41a5e  
    3636#include <errno.h>
    3737
    38 static int devmap_phone = -1;
     38static int devmap_phone_driver = -1;
     39static int devmap_phone_client = -1;
    3940
    4041/** Get phone to device mapper task. */
    41 static int devmap_get_phone(unsigned int flags)
    42 {
    43         int phone;
    44 
    45         if (devmap_phone >= 0)
    46                 return devmap_phone;
    47 
    48         if (flags & IPC_FLAG_BLOCKING) {
    49                 phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
    50                     DEVMAP_CLIENT, 0);
    51         } else {
    52                 phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
    53                     DEVMAP_CLIENT, 0);
    54         }
    55 
    56         if (phone < 0)
    57                 return phone;
    58 
    59         devmap_phone = phone;
    60         return phone;
     42int devmap_get_phone(devmap_interface_t iface, unsigned int flags)
     43{
     44        switch (iface) {
     45        case DEVMAP_DRIVER:
     46                if (devmap_phone_driver >= 0)
     47                        return devmap_phone_driver;
     48               
     49                if (flags & IPC_FLAG_BLOCKING)
     50                        devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
     51                            SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
     52                else
     53                        devmap_phone_driver = ipc_connect_me_to(PHONE_NS,
     54                            SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
     55               
     56                return devmap_phone_driver;
     57        case DEVMAP_CLIENT:
     58                if (devmap_phone_client >= 0)
     59                        return devmap_phone_client;
     60               
     61                if (flags & IPC_FLAG_BLOCKING)
     62                        devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
     63                            SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     64                else
     65                        devmap_phone_client = ipc_connect_me_to(PHONE_NS,
     66                            SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
     67               
     68                return devmap_phone_client;
     69        default:
     70                return -1;
     71        }
     72}
     73
     74void devmap_hangup_phone(devmap_interface_t iface)
     75{
     76        switch (iface) {
     77        case DEVMAP_DRIVER:
     78                if (devmap_phone_driver >= 0) {
     79                        ipc_hangup(devmap_phone_driver);
     80                        devmap_phone_driver = -1;
     81                }
     82                break;
     83        case DEVMAP_CLIENT:
     84                if (devmap_phone_client >= 0) {
     85                        ipc_hangup(devmap_phone_client);
     86                        devmap_phone_client = -1;
     87                }
     88                break;
     89        default:
     90                break;
     91        }
    6192}
    6293
    … …  
    6495int devmap_driver_register(const char *name, async_client_conn_t conn)
    6596{
    66         ipcarg_t retval;
    67         aid_t req;
    68         ipc_call_t answer;
    69         int phone;
     97        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
     98       
     99        if (phone < 0)
     100                return phone;
     101       
     102        ipc_call_t answer;
     103        aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
     104       
     105        ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
     106       
     107        if (retval != EOK) {
     108                async_wait_for(req, NULL);
     109                return -1;
     110        }
     111       
     112        async_set_client_connection(conn);
     113       
    70114        ipcarg_t callback_phonehash;
    71 
    72         phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
    73             DEVMAP_DRIVER, 0);
    74 
    75         if (phone < 0) {
     115        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
     116        async_wait_for(req, &retval);
     117       
     118        return retval;
     119}
     120
     121/** Register new device.
     122 *
     123 * @param name   Device name.
     124 * @param handle Output: Handle to the created instance of device.
     125 *
     126 */
     127int devmap_device_register(const char *name, dev_handle_t *handle)
     128{
     129        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
     130       
     131        if (phone < 0)
    76132                return phone;
    77         }
    78        
    79         req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
    80         retval = ipc_data_write_start(phone, name, str_size(name) + 1);
    81 
    82         if (retval != EOK) {
    83                 async_wait_for(req, NULL);
    84                 ipc_hangup(phone);
    85                 return -1;
    86         }
    87 
    88         async_set_client_connection(conn);
    89 
    90         ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
    91         async_wait_for(req, &retval);
    92 
    93         return phone;
    94 }
    95 
    96 int devmap_device_get_handle(const char *name, dev_handle_t *handle,
    97     unsigned int flags)
    98 {
    99         ipcarg_t retval;
    100         aid_t req;
    101         ipc_call_t answer;
    102         int phone;
    103 
    104         phone = devmap_get_phone(flags);
    105         if (phone < 0)
    106                 return phone;
    107 
    108         req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
     133       
     134        ipc_call_t answer;
     135        aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0,
    109136            &answer);
    110 
    111         retval = ipc_data_write_start(phone, name, str_size(name) + 1);
    112 
    113         if (retval != EOK) {
    114                 async_wait_for(req, NULL);
    115                 return retval;
    116         }
    117 
    118         async_wait_for(req, &retval);
    119 
     137       
     138        ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
     139       
     140        if (retval != EOK) {
     141                async_wait_for(req, NULL);
     142                return retval;
     143        }
     144       
     145        async_wait_for(req, &retval);
     146       
    120147        if (retval != EOK) {
    121148                if (handle != NULL)
    … …  
    123150                return retval;
    124151        }
    125 
     152       
    126153        if (handle != NULL)
    127                 *handle = (int) IPC_GET_ARG1(answer);
    128 
     154                *handle = (dev_handle_t) IPC_GET_ARG1(answer);
     155       
    129156        return retval;
    130157}
    131158
     159int devmap_device_get_handle(const char *name, dev_handle_t *handle, unsigned int flags)
     160{
     161        int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
     162       
     163        if (phone < 0)
     164                return phone;
     165       
     166        ipc_call_t answer;
     167        aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
     168            &answer);
     169       
     170        ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
     171       
     172        if (retval != EOK) {
     173                async_wait_for(req, NULL);
     174                return retval;
     175        }
     176       
     177        async_wait_for(req, &retval);
     178       
     179        if (retval != EOK) {
     180                if (handle != NULL)
     181                        *handle = -1;
     182                return retval;
     183        }
     184       
     185        if (handle != NULL)
     186                *handle = (dev_handle_t) IPC_GET_ARG1(answer);
     187       
     188        return retval;
     189}
     190
    132191int devmap_device_connect(dev_handle_t handle, unsigned int flags)
    133192{
    134193        int phone;
    135 
     194       
    136195        if (flags & IPC_FLAG_BLOCKING) {
    137196                phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
    … …  
    141200                    DEVMAP_CONNECT_TO_DEVICE, handle);
    142201        }
    143 
     202       
    144203        return phone;
    145204}
    146205
    147 /** Register new device.
    148  *
    149  * @param driver_phone
    150  * @param name Device name.
    151  * @param handle Output: Handle to the created instance of device.
    152  */
    153 int devmap_device_register(int driver_phone, const char *name, int *handle)
    154 {
    155         ipcarg_t retval;
    156         aid_t req;
    157         ipc_call_t answer;
    158 
    159         req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0,
    160             &answer);
    161 
    162         retval = ipc_data_write_start(driver_phone, name, str_size(name) + 1);
    163 
    164         if (retval != EOK) {
    165                 async_wait_for(req, NULL);
    166                 return retval;
    167         }
    168 
    169         async_wait_for(req, &retval);
    170 
    171         if (retval != EOK) {
    172                 if (handle != NULL)
    173                         *handle = -1;
    174                 return retval;
    175         }
    176 
    177         *handle = (int) IPC_GET_ARG1(answer);
    178         return retval;
    179 }
     206ipcarg_t devmap_device_get_count(void)
     207{
     208        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
     209       
     210        if (phone < 0)
     211                return 0;
     212       
     213        ipcarg_t count;
     214        int retval = ipc_call_sync_0_1(phone, DEVMAP_DEVICE_GET_COUNT, &count);
     215        if (retval != EOK)
     216                return 0;
     217       
     218        return count;
     219}
     220
     221ipcarg_t devmap_device_get_devices(ipcarg_t count, dev_desc_t *data)
     222{
     223        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
     224       
     225        if (phone < 0)
     226                return 0;
     227       
     228        ipc_call_t answer;
     229        aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer);
     230       
     231        ipcarg_t retval = ipc_data_read_start(phone, data, count * sizeof(dev_desc_t));
     232       
     233        if (retval != EOK) {
     234                async_wait_for(req, NULL);
     235                return 0;
     236        }
     237       
     238        async_wait_for(req, &retval);
     239       
     240        if (retval != EOK)
     241                return 0;
     242       
     243        return IPC_GET_ARG1(answer);
     244}
Note: See TracChangeset for help on using the changeset viewer.