Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/devman.c

    re72fb34 r4db43721  
    2828 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929 */
    30 
    31 /** @addtogroup libc
     30 
     31 /** @addtogroup libc
    3232 * @{
    3333 */
     
    3737#include <str.h>
    3838#include <stdio.h>
     39#include <ipc/ipc.h>
    3940#include <ipc/services.h>
    4041#include <ipc/devman.h>
     
    115116        async_set_client_connection(conn);
    116117       
    117         async_connect_to_me(phone, 0, 0, 0, NULL);
     118        sysarg_t callback_phonehash;
     119        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
    118120        async_wait_for(req, &retval);
    119121       
     
    123125}
    124126
    125 static int devman_send_match_id(int phone, match_id_t *match_id)
    126 {
    127         ipc_call_t answer;
    128 
    129         aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score,
    130             &answer);
    131         int retval = async_data_write_start(phone, match_id->id,
    132             str_size(match_id->id));
    133 
     127static int devman_send_match_id(int phone, match_id_t *match_id) \
     128{
     129        ipc_call_t answer;
     130        aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, &answer);
     131        int retval = async_data_write_start(phone, match_id->id, str_size(match_id->id));
    134132        async_wait_for(req, NULL);
    135133        return retval;
     
    137135
    138136
    139 static int devman_send_match_ids(int phone, match_id_list_t *match_ids)
     137static int devman_send_match_ids(int phone, match_id_list_t *match_ids) 
    140138{
    141139        link_t *link = match_ids->ids.next;
    142140        match_id_t *match_id = NULL;
    143141        int ret = EOK;
    144 
     142       
    145143        while (link != &match_ids->ids) {
    146144                match_id = list_get_instance(link, match_id_t, link);
    147                 ret = devman_send_match_id(phone, match_id);
    148                 if (ret != EOK) {
    149                         return ret;
    150                 }
    151 
     145                if (EOK != (ret = devman_send_match_id(phone, match_id)))
     146                {
     147                        printf("Driver failed to send match id, error number = %d\n", ret);
     148                        return ret;                     
     149                }
    152150                link = link->next;
    153151        }
    154 
    155         return ret;
    156 }
    157 
    158 /** Add function to a device.
    159  *
    160  * Request devman to add a new function to the specified device owned by
    161  * this driver task.
    162  *
    163  * @param name          Name of the new function
    164  * @param ftype         Function type, fun_inner or fun_exposed
    165  * @param match_ids     Match IDs (should be empty for fun_exposed)
    166  * @param devh          Devman handle of the device
    167  * @param funh          Place to store handle of the new function
    168  *
    169  * @return              EOK on success or negative error code.
    170  */
    171 int devman_add_function(const char *name, fun_type_t ftype,
    172     match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
    173 {
     152        return ret;     
     153}
     154
     155int devman_child_device_register(
     156        const char *name, match_id_list_t *match_ids, devman_handle_t parent_handle, devman_handle_t *handle)
     157{               
    174158        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
    175         int fun_handle;
    176159       
    177160        if (phone < 0)
     
    180163        async_serialize_start();
    181164       
    182         int match_count = list_count(&match_ids->ids);
    183         ipc_call_t answer;
    184 
    185         aid_t req = async_send_3(phone, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
    186             devh, match_count, &answer);
     165        int match_count = list_count(&match_ids->ids); 
     166        ipc_call_t answer;
     167        aid_t req = async_send_2(phone, DEVMAN_ADD_CHILD_DEVICE, parent_handle, match_count, &answer);
    187168
    188169        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
     
    193174        }
    194175       
    195         int match_ids_rc = devman_send_match_ids(phone, match_ids);
     176        devman_send_match_ids(phone, match_ids);
    196177       
    197178        async_wait_for(req, &retval);
     
    199180        async_serialize_end();
    200181       
    201         /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */
    202         if ((match_ids_rc != EOK) && (retval == EOK)) {
    203                 retval = match_ids_rc;
    204         }
    205 
    206         if (retval == EOK)
    207                 fun_handle = (int) IPC_GET_ARG1(answer);
    208         else
    209                 fun_handle = -1;
    210        
    211         *funh = fun_handle;
    212 
     182        if (retval != EOK) {
     183                if (handle != NULL) {
     184                        *handle = -1;
     185                }
     186                return retval;
     187        }       
     188       
     189        if (handle != NULL)
     190                *handle = (int) IPC_GET_ARG1(answer);   
     191               
    213192        return retval;
    214193}
    215194
    216 int devman_add_device_to_class(devman_handle_t devman_handle,
    217     const char *class_name)
     195int devman_add_device_to_class(devman_handle_t devman_handle, const char *class_name)
    218196{
    219197        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
     
    224202        async_serialize_start();
    225203        ipc_call_t answer;
    226         aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS,
    227             devman_handle, &answer);
    228        
    229         sysarg_t retval = async_data_write_start(phone, class_name,
    230             str_size(class_name));
     204        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, devman_handle, &answer);
     205       
     206        sysarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
    231207        if (retval != EOK) {
    232208                async_wait_for(req, NULL);
     
    238214        async_serialize_end();
    239215       
    240         return retval;
     216        return retval; 
    241217}
    242218
     
    246222        case DEVMAN_DRIVER:
    247223                if (devman_phone_driver >= 0) {
    248                         async_hangup(devman_phone_driver);
     224                        ipc_hangup(devman_phone_driver);
    249225                        devman_phone_driver = -1;
    250226                }
     
    252228        case DEVMAN_CLIENT:
    253229                if (devman_phone_client >= 0) {
    254                         async_hangup(devman_phone_client);
     230                        ipc_hangup(devman_phone_client);
    255231                        devman_phone_client = -1;
    256232                }
     
    291267}
    292268
    293 int devman_device_get_handle(const char *pathname, devman_handle_t *handle,
    294     unsigned int flags)
     269int devman_device_get_handle(const char *pathname, devman_handle_t *handle, unsigned int flags)
    295270{
    296271        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
     
    305280            &answer);
    306281       
    307         sysarg_t retval = async_data_write_start(phone, pathname,
    308             str_size(pathname));
     282        sysarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
    309283        if (retval != EOK) {
    310284                async_wait_for(req, NULL);
     
    329303}
    330304
    331 int devman_device_get_handle_by_class(const char *classname,
    332     const char *devname, devman_handle_t *handle, unsigned int flags)
    333 {
    334         int phone = devman_get_phone(DEVMAN_CLIENT, flags);
    335 
    336         if (phone < 0)
    337                 return phone;
    338 
    339         async_serialize_start();
    340 
    341         ipc_call_t answer;
    342         aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
    343             flags, &answer);
    344 
    345         sysarg_t retval = async_data_write_start(phone, classname,
    346             str_size(classname));
    347         if (retval != EOK) {
    348                 async_wait_for(req, NULL);
    349                 async_serialize_end();
    350                 return retval;
    351         }
    352         retval = async_data_write_start(phone, devname,
    353             str_size(devname));
    354         if (retval != EOK) {
    355                 async_wait_for(req, NULL);
    356                 async_serialize_end();
    357                 return retval;
    358         }
    359 
    360         async_wait_for(req, &retval);
    361 
    362         async_serialize_end();
    363 
    364         if (retval != EOK) {
    365                 if (handle != NULL)
    366                         *handle = (devman_handle_t) -1;
    367                 return retval;
    368         }
    369 
    370         if (handle != NULL)
    371                 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    372 
    373         return retval;
    374 }
    375 
    376305
    377306/** @}
Note: See TracChangeset for help on using the changeset viewer.