Changeset 79ae36dd in mainline for uspace/lib/usbhid/src/hidiface.c


Ignore:
Timestamp:
2011-06-08T19:01:55Z (13 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.)
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbhid/src/hidiface.c

    r764d71e r79ae36dd  
    4343/** Ask for event array length.
    4444 *
    45  * @param dev_phone Opened phone to DDF device providing USB HID interface.
     45 * @param dev_sess Session to DDF device providing USB HID interface.
     46 *
    4647 * @return Number of usages returned or negative error code.
    47  */
    48 int usbhid_dev_get_event_length(int dev_phone, size_t *size)
    49 {
    50         if (dev_phone < 0) {
    51                 return EINVAL;
    52         }
    53 
     48 *
     49 */
     50int usbhid_dev_get_event_length(async_sess_t *dev_sess, size_t *size)
     51{
     52        if (!dev_sess)
     53                return EINVAL;
     54       
     55        async_exch_t *exch = async_exchange_begin(dev_sess);
     56       
    5457        sysarg_t len;
    55         int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE),
     58        int rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE),
    5659            IPC_M_USBHID_GET_EVENT_LENGTH, &len);
     60       
     61        async_exchange_end(exch);
     62       
    5763        if (rc == EOK) {
    58                 if (size != NULL) {
     64                if (size != NULL)
    5965                        *size = (size_t) len;
    60                 }
    6166        }
    6267       
    … …  
    6671/** Request for next event from HID device.
    6772 *
    68  * @param[in] dev_phone Opened phone to DDF device providing USB HID interface.
     73 * @param[in]  dev_sess    Session to DDF device providing USB HID interface.
    6974 * @param[out] usage_pages Where to store usage pages.
    70  * @param[out] usages Where to store usages (actual data).
    71  * @param[in] usage_count Length of @p usage_pages and @p usages buffer
    72  *      (in items, not bytes).
     75 * @param[out] usages      Where to store usages (actual data).
     76 * @param[in]  usage_count Length of @p usage_pages and @p usages buffer
     77 *                         (in items, not bytes).
    7378 * @param[out] actual_usage_count Number of usages actually returned by the
    74  *      device driver.
    75  * @param[in] flags Flags (see USBHID_IFACE_FLAG_*).
     79 *                                device driver.
     80 * @param[in] flags        Flags (see USBHID_IFACE_FLAG_*).
     81 *
    7682 * @return Error code.
    77  */
    78 int usbhid_dev_get_event(int dev_phone, uint8_t *buf,
     83 *
     84 */
     85int usbhid_dev_get_event(async_sess_t *dev_sess, uint8_t *buf,
    7986    size_t size, size_t *actual_size, int *event_nr, unsigned int flags)
    8087{
    81         if (dev_phone < 0) {
    82                 return EINVAL;
    83         }
    84         if ((buf == NULL)) {
    85                 return ENOMEM;
    86         }
    87         if (size == 0) {
    88                 return EINVAL;
    89         }
    90        
    91 //      if (size == 0) {
    92 //              return EOK;
    93 //      }
    94 
     88        if (!dev_sess)
     89                return EINVAL;
     90       
     91        if ((buf == NULL))
     92                return ENOMEM;
     93       
     94        if (size == 0)
     95                return EINVAL;
     96       
    9597        size_t buffer_size =  size;
    9698        uint8_t *buffer = malloc(buffer_size);
    97         if (buffer == NULL) {
    98                 return ENOMEM;
    99         }
    100 
     99        if (buffer == NULL)
     100                return ENOMEM;
     101       
     102        async_exch_t *exch = async_exchange_begin(dev_sess);
     103       
    101104        ipc_call_t opening_request_call;
    102         aid_t opening_request = async_send_2(dev_phone,
     105        aid_t opening_request = async_send_2(exch,
    103106            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT,
    104107            flags, &opening_request_call);
     108       
    105109        if (opening_request == 0) {
     110                async_exchange_end(exch);
    106111                free(buffer);
    107112                return ENOMEM;
    108113        }
    109 
     114       
    110115        ipc_call_t data_request_call;
    111         aid_t data_request = async_data_read(dev_phone, buffer, buffer_size,
     116        aid_t data_request = async_data_read(exch, buffer, buffer_size,
    112117            &data_request_call);
     118       
     119        async_exchange_end(exch);
     120       
    113121        if (data_request == 0) {
    114122                async_wait_for(opening_request, NULL);
    … …  
    116124                return ENOMEM;
    117125        }
    118 
     126       
    119127        sysarg_t data_request_rc;
    120128        sysarg_t opening_request_rc;
    121129        async_wait_for(data_request, &data_request_rc);
    122130        async_wait_for(opening_request, &opening_request_rc);
    123 
     131       
    124132        if (data_request_rc != EOK) {
    125133                /* Prefer return code of the opening request. */
    126                 if (opening_request_rc != EOK) {
     134                if (opening_request_rc != EOK)
    127135                        return (int) opening_request_rc;
    128                 } else {
     136                else
    129137                        return (int) data_request_rc;
    130                 }
    131         }
    132 
    133         if (opening_request_rc != EOK) {
     138        }
     139       
     140        if (opening_request_rc != EOK)
    134141                return (int) opening_request_rc;
    135         }
    136 
     142       
    137143        size_t act_size = IPC_GET_ARG2(data_request_call);
    138 
     144       
    139145        /* Copy the individual items. */
    140146        memcpy(buf, buffer, act_size);
    141 //      memcpy(usages, buffer + items, items * sizeof(int32_t));
    142 
    143         if (actual_size != NULL) {
     147       
     148        if (actual_size != NULL)
    144149                *actual_size = act_size;
    145         }
    146        
    147         if (event_nr != NULL) {
     150       
     151        if (event_nr != NULL)
    148152                *event_nr = IPC_GET_ARG1(opening_request_call);
    149         }
    150 
     153       
    151154        return EOK;
    152155}
    153156
    154 
    155 int usbhid_dev_get_report_descriptor_length(int dev_phone, size_t *size)
    156 {
    157         if (dev_phone < 0) {
    158                 return EINVAL;
    159         }
    160 
     157int usbhid_dev_get_report_descriptor_length(async_sess_t *dev_sess,
     158    size_t *size)
     159{
     160        if (!dev_sess)
     161                return EINVAL;
     162       
     163        async_exch_t *exch = async_exchange_begin(dev_sess);
     164       
    161165        sysarg_t arg_size;
    162         int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(USBHID_DEV_IFACE),
     166        int rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE),
    163167            IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
     168       
     169        async_exchange_end(exch);
     170       
    164171        if (rc == EOK) {
    165                 if (size != NULL) {
     172                if (size != NULL)
    166173                        *size = (size_t) arg_size;
    167                 }
    168         }
     174        }
     175       
    169176        return rc;
    170177}
    171178
    172 int usbhid_dev_get_report_descriptor(int dev_phone, uint8_t *buf, size_t size,
    173     size_t *actual_size)
    174 {
    175         if (dev_phone < 0) {
    176                 return EINVAL;
    177         }
    178         if ((buf == NULL)) {
    179                 return ENOMEM;
    180         }
    181         if (size == 0) {
    182                 return EINVAL;
    183         }
    184 
    185         aid_t opening_request = async_send_1(dev_phone,
     179int usbhid_dev_get_report_descriptor(async_sess_t *dev_sess, uint8_t *buf,
     180    size_t size, size_t *actual_size)
     181{
     182        if (!dev_sess)
     183                return EINVAL;
     184       
     185        if ((buf == NULL))
     186                return ENOMEM;
     187       
     188        if (size == 0)
     189                return EINVAL;
     190       
     191        async_exch_t *exch = async_exchange_begin(dev_sess);
     192       
     193        aid_t opening_request = async_send_1(exch,
    186194            DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
    187195            NULL);
    188196        if (opening_request == 0) {
    189                 return ENOMEM;
    190         }
    191 
     197                async_exchange_end(exch);
     198                return ENOMEM;
     199        }
     200       
    192201        ipc_call_t data_request_call;
    193         aid_t data_request = async_data_read(dev_phone, buf, size,
     202        aid_t data_request = async_data_read(exch, buf, size,
    194203            &data_request_call);
     204       
     205        async_exchange_end(exch);
     206       
    195207        if (data_request == 0) {
    196208                async_wait_for(opening_request, NULL);
    197209                return ENOMEM;
    198210        }
    199 
     211       
    200212        sysarg_t data_request_rc;
    201213        sysarg_t opening_request_rc;
    202214        async_wait_for(data_request, &data_request_rc);
    203215        async_wait_for(opening_request, &opening_request_rc);
    204 
     216       
    205217        if (data_request_rc != EOK) {
    206218                /* Prefer return code of the opening request. */
    207                 if (opening_request_rc != EOK) {
     219                if (opening_request_rc != EOK)
    208220                        return (int) opening_request_rc;
    209                 } else {
     221                else
    210222                        return (int) data_request_rc;
    211                 }
    212         }
    213 
    214         if (opening_request_rc != EOK) {
     223        }
     224       
     225        if (opening_request_rc != EOK)
    215226                return (int) opening_request_rc;
    216         }
    217 
     227       
    218228        size_t act_size = IPC_GET_ARG2(data_request_call);
    219 
    220         if (actual_size != NULL) {
     229       
     230        if (actual_size != NULL)
    221231                *actual_size = act_size;
    222         }
    223 
     232       
    224233        return EOK;
    225234}
Note: See TracChangeset for help on using the changeset viewer.