Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/net/generic/generic.c

    r28a3e74 r00d7e1b  
    4444/** Notify the module about the device state change.
    4545 *
    46  * @param[in] phone     The service module phone.
    47  * @param[in] message   The service specific message.
    48  * @param[in] device_id The device identifier.
    49  * @param[in] state     The new device state.
    50  * @param[in] target    The target module service.
    51  * @return              EOK on success.
    52  *
    53  */
    54 int
    55 generic_device_state_msg_remote(int phone, int message, device_id_t device_id,
    56     int state, services_t target)
    57 {
    58         async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    59             (sysarg_t) state, target);
     46 * @param[in] sess      Service module session.
     47 * @param[in] message   Service specific message.
     48 * @param[in] device_id Device identifier.
     49 * @param[in] state     New device state.
     50 * @param[in] target    Target module service.
     51 *
     52 * @return EOK on success.
     53 *
     54 */
     55int generic_device_state_msg_remote(async_sess_t *sess, sysarg_t message,
     56    nic_device_id_t device_id, sysarg_t state, services_t target)
     57{
     58        async_exch_t *exch = async_exchange_begin(sess);
     59        async_msg_3(exch, message, (sysarg_t) device_id, state, target);
     60        async_exchange_end(exch);
    6061       
    6162        return EOK;
    … …  
    6465/** Notify a module about the device.
    6566 *
    66  * @param[in] phone     The service module phone.
    67  * @param[in] message   The service specific message.
    68  * @param[in] device_id The device identifier.
    69  * @param[in] arg2      The second argument of the message.
    70  * @param[in] service   The device module service.
    71  * @return              EOK on success.
    72  * @return              Other error codes as defined for the specific service
    73  *                       message.
    74  *
    75  */
    76 int
    77 generic_device_req_remote(int phone, int message, device_id_t device_id,
    78     int arg2, services_t service)
    79 {
    80         return (int) async_req_3_0(phone, (sysarg_t) message,
    81             (sysarg_t) device_id, (sysarg_t) arg2, (sysarg_t) service);
     67 * @param[in] sess      Service module session.
     68 * @param[in] message   Service specific message.
     69 * @param[in] device_id Device identifier.
     70 * @param[in] service   Device module service.
     71 *
     72 * @return EOK on success.
     73 * @return Other error codes as defined for the specific service
     74 *         message.
     75 *
     76 */
     77int generic_device_req_remote(async_sess_t *sess, sysarg_t message,
     78    nic_device_id_t device_id, services_t service)
     79{
     80        async_exch_t *exch = async_exchange_begin(sess);
     81        int rc = async_req_3_0(exch, message, (sysarg_t) device_id, 0,
     82            (sysarg_t) service);
     83        async_exchange_end(exch);
     84       
     85        return rc;
    8286}
    8387
    8488/** Returns the address.
    8589 *
    86  * @param[in] phone     The service module phone.
    87  * @param[in] message   The service specific message.
    88  * @param[in] device_id The device identifier.
    89  * @param[out] address  The desired address.
    90  * @param[out] data     The address data container.
    91  * @return              EOK on success.
    92  * @return              EBADMEM if the address parameter and/or the data
    93  *                      parameter is NULL.
    94  * @return              Other error codes as defined for the specific service
    95  *                      message.
    96  */
    97 int
    98 generic_get_addr_req(int phone, int message, device_id_t device_id,
    99     measured_string_t **address, uint8_t **data)
    100 {
    101         aid_t message_id;
     90 * @param[in] sess      Service module session.
     91 * @param[in] message   Service specific message.
     92 * @param[in] device_id Device identifier.
     93 * @param[out] address  Desired address.
     94 * @param[out] data     Address data container.
     95 *
     96 * @return EOK on success.
     97 * @return EBADMEM if the address parameter and/or the data
     98 *         parameter is NULL.
     99 * @return Other error codes as defined for the specific service
     100 *         message.
     101 *
     102 */
     103int generic_get_addr_req(async_sess_t *sess, sysarg_t message,
     104    nic_device_id_t device_id, uint8_t *address, size_t max_len)
     105{
     106        if (!address)
     107                return EBADMEM;
     108       
     109        /* Request the address */
     110        async_exch_t *exch = async_exchange_begin(sess);
     111        aid_t aid = async_send_1(exch, message, (sysarg_t) device_id,
     112            NULL);
     113        int rc = async_data_read_start(exch, address, max_len);
     114        async_exchange_end(exch);
     115       
    102116        sysarg_t result;
    103         int string;
    104 
    105         if (!address || !data)
    106                 return EBADMEM;
    107 
    108         /* Request the address */
    109         message_id = async_send_1(phone, (sysarg_t) message,
    110             (sysarg_t) device_id, NULL);
    111         string = measured_strings_return(phone, address, data, 1);
    112         async_wait_for(message_id, &result);
    113 
    114         /* If not successful */
    115         if ((string == EOK) && (result != EOK)) {
    116                 /* Clear the data */
    117                 free(*address);
    118                 free(*data);
    119         }
     117        async_wait_for(aid, &result);
     118       
     119        if (rc != EOK)
     120                return rc;
    120121       
    121122        return (int) result;
    … …  
    124125/** Return the device packet dimension for sending.
    125126 *
    126  * @param[in] phone     The service module phone.
    127  * @param[in] message   The service specific message.
    128  * @param[in] device_id The device identifier.
    129  * @param[out] packet_dimension The packet dimension.
    130  * @return              EOK on success.
    131  * @return              EBADMEM if the packet_dimension parameter is NULL.
    132  * @return              Other error codes as defined for the specific service
    133  *                      message.
    134  */
    135 int
    136 generic_packet_size_req_remote(int phone, int message, device_id_t device_id,
    137     packet_dimension_t *packet_dimension)
     127 * @param[in] sess              Service module session.
     128 * @param[in] message           Service specific message.
     129 * @param[in] device_id         Device identifier.
     130 * @param[out] packet_dimension Packet dimension.
     131 *
     132 * @return EOK on success.
     133 * @return EBADMEM if the packet_dimension parameter is NULL.
     134 * @return Other error codes as defined for the specific service
     135 *         message.
     136 *
     137 */
     138int generic_packet_size_req_remote(async_sess_t *sess, sysarg_t message,
     139    nic_device_id_t device_id, packet_dimension_t *packet_dimension)
    138140{
    139141        if (!packet_dimension)
    … …  
    145147        sysarg_t suffix;
    146148       
    147         sysarg_t result = async_req_1_4(phone, (sysarg_t) message,
    148             (sysarg_t) device_id, &addr_len, &prefix, &content, &suffix);
     149        async_exch_t *exch = async_exchange_begin(sess);
     150        sysarg_t result = async_req_1_4(exch, message, (sysarg_t) device_id,
     151            &addr_len, &prefix, &content, &suffix);
     152        async_exchange_end(exch);
    149153       
    150154        packet_dimension->prefix = (size_t) prefix;
    … …  
    158162/** Pass the packet queue to the module.
    159163 *
    160  * @param[in] phone     The service module phone.
    161  * @param[in] message   The service specific message.
    162  * @param[in] device_id The device identifier.
    163  * @param[in] packet_id The received packet or the received packet queue
    164  *                      identifier.
    165  * @param[in] target    The target module service.
    166  * @param[in] error     The error module service.
    167  * @return              EOK on success.
    168  */
    169 int
    170 generic_received_msg_remote(int phone, int message, device_id_t device_id,
    171     packet_id_t packet_id, services_t target, services_t error)
    172 {
     164 * @param[in] sess      Service module session.
     165 * @param[in] message   Service specific message.
     166 * @param[in] device_id Device identifier.
     167 * @param[in] packet_id Received packet or the received packet queue
     168 *                      identifier.
     169 * @param[in] target    Target module service.
     170 * @param[in] error     Error module service.
     171 *
     172 * @return EOK on success.
     173 *
     174 */
     175int generic_received_msg_remote(async_sess_t *sess, sysarg_t message,
     176    nic_device_id_t device_id, packet_id_t packet_id, services_t target,
     177    services_t error)
     178{
     179        async_exch_t *exch = async_exchange_begin(sess);
     180       
    173181        if (error) {
    174                 async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     182                async_msg_4(exch, message, (sysarg_t) device_id,
    175183                    (sysarg_t) packet_id, (sysarg_t) target, (sysarg_t) error);
    176184        } else {
    177                 async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     185                async_msg_3(exch, message, (sysarg_t) device_id,
    178186                    (sysarg_t) packet_id, (sysarg_t) target);
    179187        }
    180188       
     189        async_exchange_end(exch);
     190       
    181191        return EOK;
    182192}
    … …  
    184194/** Send the packet queue.
    185195 *
    186  * @param[in] phone     The service module phone.
    187  * @param[in] message   The service specific message.
    188  * @param[in] device_id The device identifier.
    189  * @param[in] packet_id The packet or the packet queue identifier.
    190  * @param[in] sender    The sending module service.
    191  * @param[in] error     The error module service.
    192  * @return              EOK on success.
    193  *
    194  */
    195 int
    196 generic_send_msg_remote(int phone, int message, device_id_t device_id,
    197     packet_id_t packet_id, services_t sender, services_t error)
    198 {
     196 * @param[in] sess      Service module session.
     197 * @param[in] message   Service specific message.
     198 * @param[in] device_id Device identifier.
     199 * @param[in] packet_id Packet or the packet queue identifier.
     200 * @param[in] sender    Sending module service.
     201 * @param[in] error     Error module service.
     202 *
     203 * @return EOK on success.
     204 *
     205 */
     206int generic_send_msg_remote(async_sess_t *sess, sysarg_t message,
     207    nic_device_id_t device_id, packet_id_t packet_id, services_t sender,
     208    services_t error)
     209{
     210        async_exch_t *exch = async_exchange_begin(sess);
     211       
    199212        if (error) {
    200                 async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     213                async_msg_4(exch, message, (sysarg_t) device_id,
    201214                    (sysarg_t) packet_id, (sysarg_t) sender, (sysarg_t) error);
    202215        } else {
    203                 async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     216                async_msg_3(exch, message, (sysarg_t) device_id,
    204217                    (sysarg_t) packet_id, (sysarg_t) sender);
    205218        }
    206219       
     220        async_exchange_end(exch);
     221       
    207222        return EOK;
    208223}
    … …  
    212227 * Allocates and returns the needed memory block as the data parameter.
    213228 *
    214  * @param[in] phone     The service module phone.
    215  * @param[in] message   The service specific message.
    216  * @param[in] device_id The device identifier.
    217  * @param[in] service   The module service.
    218  * @param[in] configuration The key strings.
    219  * @param[in] count     The number of configuration keys.
    220  * @param[out] translation The translated values.
    221  * @param[out] data     The translation data container.
    222  * @return              EOK on success.
    223  * @return              EINVAL if the configuration parameter is NULL.
    224  * @return              EINVAL if the count parameter is zero.
    225  * @return              EBADMEM if the translation or the data parameters are
    226  *                      NULL.
    227  * @return              Other error codes as defined for the specific service
    228  *                      message.
    229  */
    230 int
    231 generic_translate_req(int phone, int message, device_id_t device_id,
    232     services_t service, measured_string_t *configuration, size_t count,
     229 * @param[in] sess          Service module session.
     230 * @param[in] message       Service specific message.
     231 * @param[in] device_id     Device identifier.
     232 * @param[in] service       Module service.
     233 * @param[in] configuration Key strings.
     234 * @param[in] count         Number of configuration keys.
     235 * @param[out] translation  Translated values.
     236 * @param[out] data         Translation data container.
     237 *
     238 * @return EOK on success.
     239 * @return EINVAL if the configuration parameter is NULL.
     240 * @return EINVAL if the count parameter is zero.
     241 * @return EBADMEM if the translation or the data parameters are
     242 *         NULL.
     243 * @return Other error codes as defined for the specific service
     244 *         message.
     245 *
     246 */
     247int generic_translate_req(async_sess_t *sess, sysarg_t message,
     248    nic_device_id_t device_id, services_t service,
     249    measured_string_t *configuration, size_t count,
    233250    measured_string_t **translation, uint8_t **data)
    234251{
    235         aid_t message_id;
     252        if ((!configuration) || (count == 0))
     253                return EINVAL;
     254       
     255        if ((!translation) || (!data))
     256                return EBADMEM;
     257       
     258        /* Request the translation */
     259        async_exch_t *exch = async_exchange_begin(sess);
     260        aid_t message_id = async_send_3(exch, message, (sysarg_t) device_id,
     261            (sysarg_t) count, (sysarg_t) service, NULL);
     262        measured_strings_send(exch, configuration, count);
     263        int rc = measured_strings_return(exch, translation, data, count);
     264        async_exchange_end(exch);
     265       
    236266        sysarg_t result;
    237         int string;
    238 
    239         if (!configuration || (count == 0))
    240                 return EINVAL;
    241         if (!translation || !data)
    242                 return EBADMEM;
    243 
    244         /* Request the translation */
    245         message_id = async_send_3(phone, (sysarg_t) message,
    246             (sysarg_t) device_id, (sysarg_t) count, (sysarg_t) service, NULL);
    247         measured_strings_send(phone, configuration, count);
    248         string = measured_strings_return(phone, translation, data, count);
    249267        async_wait_for(message_id, &result);
    250 
     268       
    251269        /* If not successful */
    252         if ((string == EOK) && (result != EOK)) {
     270        if ((rc == EOK) && (result != EOK)) {
    253271                /* Clear the data */
    254272                free(*translation);
    255273                free(*data);
    256274        }
    257 
     275       
    258276        return (int) result;
    259277}
Note: See TracChangeset for help on using the changeset viewer.