Changeset 5da7199 in mainline for uspace/drv


Ignore:
Timestamp:
2011-09-09T17:18:06Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3781092, b7c33b0
Parents:
c69646f8
Message:

remove the obsolete async API

Location:
uspace/drv/bus/usb/usbhid
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/usbhid/kbd/kbddev.c

    rc69646f8 r5da7199  
    4343#include <ipc/kbdev.h>
    4444#include <async.h>
    45 #include <async_obsolete.h>
    4645#include <fibril.h>
    4746#include <fibril_synch.h>
    … …  
    7069
    7170#include "../usbhid.h"
    72 
    73 // FIXME: remove this header
    74 #include <abi/ipc/methods.h>
    7571
    7672/*----------------------------------------------------------------------------*/
    … …  
    167163 *
    168164 * Currently recognizes only one method (IPC_M_CONNECT_TO_ME), in which case it
    169  * assumes the caller is the console and thus it stores IPC phone to it for
     165 * assumes the caller is the console and thus it stores IPC session to it for
    170166 * later use by the driver to notify about key events.
    171167 *
    … …  
    178174{
    179175        sysarg_t method = IPC_GET_IMETHOD(*icall);
    180         int callback;
    181        
    182         usb_kbd_t *kbd_dev = (usb_kbd_t *)fun->driver_data;
     176       
     177        usb_kbd_t *kbd_dev = (usb_kbd_t *) fun->driver_data;
    183178        if (kbd_dev == NULL) {
    184179                usb_log_debug("default_connection_handler: "
    … …  
    187182                return;
    188183        }
    189 
    190         switch (method) {
    191         case IPC_M_CONNECT_TO_ME:
    192                 callback = IPC_GET_ARG5(*icall);
    193 
    194                 if (kbd_dev->console_phone != -1) {
     184       
     185        async_sess_t *sess =
     186            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     187        if (sess != NULL) {
     188                if (kbd_dev->console_sess == NULL) {
     189                        kbd_dev->console_sess = sess;
     190                        usb_log_debug("default_connection_handler: OK\n");
     191                        async_answer_0(icallid, EOK);
     192                } else {
    195193                        usb_log_debug("default_connection_handler: "
    196                             "console phone already set\n");
     194                            "console session already set\n");
    197195                        async_answer_0(icallid, ELIMIT);
    198                         return;
    199                 }
    200 
    201                 kbd_dev->console_phone = callback;
    202                
    203                 usb_log_debug("default_connection_handler: OK\n");
    204                 async_answer_0(icallid, EOK);
    205                 break;
    206         case KBDEV_SET_IND:
    207                 kbd_dev->mods = IPC_GET_ARG1(*icall);
    208                 usb_kbd_set_led(kbd_dev->hid_dev, kbd_dev);
    209                 async_answer_0(icallid, EOK);
    210                 break;
    211         default:
    212                 usb_log_debug("default_connection_handler: Wrong function.\n");
    213                 async_answer_0(icallid, EINVAL);
    214                 break;
     196                }
     197        } else {
     198                switch (method) {
     199                case KBDEV_SET_IND:
     200                        kbd_dev->mods = IPC_GET_ARG1(*icall);
     201                        usb_kbd_set_led(kbd_dev->hid_dev, kbd_dev);
     202                        async_answer_0(icallid, EOK);
     203                        break;
     204                default:
     205                        usb_log_debug("default_connection_handler: Wrong function.\n");
     206                        async_answer_0(icallid, EINVAL);
     207                        break;
     208                }
    215209        }
    216210}
    … …  
    301295{
    302296        usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
    303         if (kbd_dev->console_phone < 0) {
     297        if (kbd_dev->console_sess == NULL) {
    304298                usb_log_warning(
    305299                    "Connection to console not ready, key discarded.\n");
    … …  
    307301        }
    308302       
    309         async_obsolete_msg_2(kbd_dev->console_phone, KBDEV_EVENT, type, key);
     303        async_exch_t *exch = async_exchange_begin(kbd_dev->console_sess);
     304        async_msg_2(exch, KBDEV_EVENT, type, key);
     305        async_exchange_end(exch);
    310306}
    311307
    … …  
    510506        }
    511507       
    512         kbd_dev->console_phone = -1;
     508        kbd_dev->console_sess = NULL;
    513509        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
    514510       
    … …  
    785781        }
    786782       
    787         // hangup phone to the console
    788         async_obsolete_hangup(kbd_dev->console_phone);
     783        // hangup session to the console
     784        async_hangup(kbd_dev->console_sess);
    789785       
    790786        if (kbd_dev->repeat_mtx != NULL) {

  • uspace/drv/bus/usb/usbhid/kbd/kbddev.h

    rc69646f8 r5da7199  
    3838
    3939#include <stdint.h>
    40 
     40#include <async.h>
    4141#include <fibril_synch.h>
    42 
    4342#include <usb/hid/hid.h>
    4443#include <usb/hid/hidparser.h>
    … …  
    5857 * data, such as currently pressed keys, modifiers and lock keys.
    5958 *
    60  * Also holds a IPC phone to the console (since there is now no other way to
     59 * Also holds a IPC session to the console (since there is now no other way to
    6160 * communicate with it).
    6261 *
    … …  
    8382        unsigned lock_keys;
    8483       
    85         /** IPC phone to the console device (for sending key events). */
    86         int console_phone;
     84        /** IPC session to the console device (for sending key events). */
     85        async_sess_t *console_sess;
    8786       
    8887        /** @todo What is this actually? */

  • uspace/drv/bus/usb/usbhid/mouse/mousedev.c

    rc69646f8 r5da7199  
    4242#include <errno.h>
    4343#include <async.h>
    44 #include <async_obsolete.h>
    4544#include <str_error.h>
    4645#include <ipc/mouseev.h>
    … …  
    5655#define ARROWS_PER_SINGLE_WHEEL 3
    5756
    58 // FIXME: remove this header
    59 #include <abi/ipc/methods.h>
    60 
    61 #define NAME "mouse"
     57#define NAME  "mouse"
    6258
    6359/*----------------------------------------------------------------------------*/
    … …  
    128124    ipc_callid_t icallid, ipc_call_t *icall)
    129125{
    130         sysarg_t method = IPC_GET_IMETHOD(*icall);
    131        
    132         usb_mouse_t *mouse_dev = (usb_mouse_t *)fun->driver_data;
     126        usb_mouse_t *mouse_dev = (usb_mouse_t *) fun->driver_data;
    133127       
    134128        if (mouse_dev == NULL) {
    … …  
    141135        usb_log_debug("default_connection_handler: fun->name: %s\n",
    142136                      fun->name);
    143         usb_log_debug("default_connection_handler: mouse_phone: %d, wheel "
    144             "phone: %d\n", mouse_dev->mouse_phone, mouse_dev->wheel_phone);
    145        
    146         int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0)
    147                      ? &mouse_dev->mouse_phone : &mouse_dev->wheel_phone;
    148        
    149         if (method == IPC_M_CONNECT_TO_ME) {
    150                 int callback = IPC_GET_ARG5(*icall);
    151 
    152                 if (*phone != -1) {
     137        usb_log_debug("default_connection_handler: mouse_sess: %p, "
     138            "wheel_sess: %p\n", mouse_dev->mouse_sess, mouse_dev->wheel_sess);
     139       
     140        async_sess_t **sess_ptr =
     141            (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0) ?
     142            &mouse_dev->mouse_sess : &mouse_dev->wheel_sess;
     143       
     144        async_sess_t *sess =
     145            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     146        if (sess != NULL) {
     147                if (*sess_ptr == NULL) {
     148                        *sess_ptr = sess;
     149                        usb_log_debug("Console session to mouse set ok (%p).\n",
     150                            sess);
     151                        async_answer_0(icallid, EOK);
     152                } else {
    153153                        usb_log_debug("default_connection_handler: Console "
    154                             "phone to mouse already set.\n");
     154                            "session to mouse already set.\n");
    155155                        async_answer_0(icallid, ELIMIT);
    156                         return;
    157156                }
    158 
    159                 *phone = callback;
    160                 usb_log_debug("Console phone to mouse set ok (%d).\n", *phone);
    161                 async_answer_0(icallid, EOK);
    162                 return;
    163         }
    164 
    165         usb_log_debug("default_connection_handler: Invalid function.\n");
    166         async_answer_0(icallid, EINVAL);
     157        } else {
     158                usb_log_debug("default_connection_handler: Invalid function.\n");
     159                async_answer_0(icallid, EINVAL);
     160        }
    167161}
    168162
    … …  
    175169                return NULL;
    176170        }
    177         mouse->mouse_phone = -1;
    178         mouse->wheel_phone = -1;
     171        mouse->mouse_sess = NULL;
     172        mouse->wheel_sess = NULL;
    179173       
    180174        return mouse;
    … …  
    187181        assert(mouse_dev != NULL);
    188182       
    189         // hangup phone to the console
    190         if (mouse_dev->mouse_phone >= 0) {
    191                 async_obsolete_hangup(mouse_dev->mouse_phone);
    192         }
    193        
    194         if (mouse_dev->wheel_phone >= 0) {
    195                 async_obsolete_hangup(mouse_dev->wheel_phone);
    196         }
     183        // hangup session to the console
     184        if (mouse_dev->mouse_sess != NULL)
     185                async_hangup(mouse_dev->mouse_sess);
     186       
     187        if (mouse_dev->wheel_sess != NULL)
     188                async_hangup(mouse_dev->wheel_sess);
    197189}
    198190
    … …  
    203195        unsigned int key = (wheel > 0) ? KC_UP : KC_DOWN;
    204196
    205         if (mouse_dev->wheel_phone < 0) {
     197        if (mouse_dev->wheel_sess == NULL) {
    206198                usb_log_warning(
    207199                    "Connection to console not ready, wheel roll discarded.\n");
    … …  
    215207                /* Send arrow press and release. */
    216208                usb_log_debug2("Sending key %d to the console\n", key);
    217                 async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT,
    218                     KEY_PRESS, key, 0, 0);
    219                 async_obsolete_msg_4(mouse_dev->wheel_phone, KBDEV_EVENT,
    220                     KEY_RELEASE, key, 0, 0);
     209               
     210                async_exch_t *exch = async_exchange_begin(mouse_dev->wheel_sess);
     211               
     212                async_msg_4(exch, KBDEV_EVENT, KEY_PRESS, key, 0, 0);
     213                async_msg_4(exch, KBDEV_EVENT, KEY_RELEASE, key, 0, 0);
     214               
     215                async_exchange_end(exch);
    221216        }
    222217}
    … …  
    253248        assert(mouse_dev != NULL);
    254249       
    255         if (mouse_dev->mouse_phone < 0) {
    256                 usb_log_warning(NAME " No console phone.\n");
     250        if (mouse_dev->mouse_sess == NULL) {
     251                usb_log_warning(NAME " No console session.\n");
    257252                return true;
    258253        }
    … …  
    266261
    267262        if ((shift_x != 0) || (shift_y != 0)) {
    268                 async_obsolete_req_2_0(mouse_dev->mouse_phone,
    269                     MOUSEEV_MOVE_EVENT, shift_x, shift_y);
    270         }
    271 
    272         if (wheel != 0) {
     263                async_exch_t *exch = async_exchange_begin(mouse_dev->mouse_sess);
     264                async_req_2_0(exch, MOUSEEV_MOVE_EVENT, shift_x, shift_y);
     265                async_exchange_end(exch);
     266        }
     267       
     268        if (wheel != 0)
    273269                usb_mouse_send_wheel(mouse_dev, wheel);
    274         }
    275270       
    276271        /*
    … …  
    292287                if (mouse_dev->buttons[field->usage - field->usage_minimum] == 0
    293288                    && field->value != 0) {
    294                         async_obsolete_req_2_0(mouse_dev->mouse_phone,
    295                             MOUSEEV_BUTTON_EVENT, field->usage, 1);
     289                        async_exch_t *exch =
     290                            async_exchange_begin(mouse_dev->mouse_sess);
     291                        async_req_2_0(exch, MOUSEEV_BUTTON_EVENT, field->usage, 1);
     292                        async_exchange_end(exch);
     293                       
    296294                        mouse_dev->buttons[field->usage - field->usage_minimum]
    297295                            = field->value;
    298296                } else if (mouse_dev->buttons[field->usage - field->usage_minimum] != 0
    299297                    && field->value == 0) {
    300                         async_obsolete_req_2_0(mouse_dev->mouse_phone,
    301                            MOUSEEV_BUTTON_EVENT, field->usage, 0);
     298                        async_exch_t *exch =
     299                            async_exchange_begin(mouse_dev->mouse_sess);
     300                        async_req_2_0(exch, MOUSEEV_BUTTON_EVENT, field->usage, 0);
     301                        async_exchange_end(exch);
     302                       
    302303                        mouse_dev->buttons[field->usage - field->usage_minimum] =
    303304                           field->value;

  • uspace/drv/bus/usb/usbhid/mouse/mousedev.h

    rc69646f8 r5da7199  
    3838
    3939#include <usb/dev/driver.h>
     40#include <async.h>
    4041
    4142struct usb_hid_dev;
    … …  
    4546/** Container for USB mouse device. */
    4647typedef struct {
    47         /** IPC phone to console (consumer). */
    48         int mouse_phone;
    49         int wheel_phone;
     48        /** IPC session to console (consumer). */
     49        async_sess_t *mouse_sess;
     50        async_sess_t *wheel_sess;
    5051       
    5152        int32_t *buttons;

  • uspace/drv/bus/usb/usbhid/multimedia/multimedia.c

    rc69646f8 r5da7199  
    4747#include <errno.h>
    4848#include <async.h>
    49 #include <async_obsolete.h>
    5049#include <str_error.h>
    5150
    … …  
    5352#include <io/console.h>
    5453
    55 // FIXME: remove this header
    56 #include <abi/ipc/methods.h>
    57 
    58 #define NAME "multimedia-keys"
     54#define NAME  "multimedia-keys"
    5955
    6056/*----------------------------------------------------------------------------*/
    … …  
    6965        /** Count of stored keys (i.e. number of keys in the report). */
    7066        //size_t key_count;     
    71         /** IPC phone to the console device (for sending key events). */
    72         int console_phone;
     67        /** IPC session to the console device (for sending key events). */
     68        async_sess_t *console_sess;
    7369} usb_multimedia_t;
    7470
    … …  
    7975 *
    8076 * Currently recognizes only one method (IPC_M_CONNECT_TO_ME), in which case it
    81  * assumes the caller is the console and thus it stores IPC phone to it for
     77 * assumes the caller is the console and thus it stores IPC session to it for
    8278 * later use by the driver to notify about key events.
    8379 *
    … …  
    9187        usb_log_debug(NAME " default_connection_handler()\n");
    9288       
    93         sysarg_t method = IPC_GET_IMETHOD(*icall);
    94        
    9589        usb_multimedia_t *multim_dev = (usb_multimedia_t *)fun->driver_data;
    9690       
    … …  
    9993                return;
    10094        }
    101 
    102         if (method == IPC_M_CONNECT_TO_ME) {
    103                 int callback = IPC_GET_ARG5(*icall);
    104 
    105                 if (multim_dev->console_phone != -1) {
     95       
     96        async_sess_t *sess =
     97            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     98        if (sess != NULL) {
     99                if (multim_dev->console_sess == NULL) {
     100                        multim_dev->console_sess = sess;
     101                        usb_log_debug(NAME " Saved session to console: %p\n",
     102                            sess);
     103                        async_answer_0(icallid, EOK);
     104                } else
    106105                        async_answer_0(icallid, ELIMIT);
    107                         return;
    108                 }
    109 
    110                 multim_dev->console_phone = callback;
    111                 usb_log_debug(NAME " Saved phone to console: %d\n", callback);
    112                 async_answer_0(icallid, EOK);
    113                 return;
    114         }
    115        
    116         async_answer_0(icallid, EINVAL);
     106        } else
     107                async_answer_0(icallid, EINVAL);
    117108}
    118109
    … …  
    155146
    156147        usb_log_debug2(NAME " Sending key %d to the console\n", ev.key);
    157         if (multim_dev->console_phone < 0) {
     148        if (multim_dev->console_sess == NULL) {
    158149                usb_log_warning(
    159150                    "Connection to console not ready, key discarded.\n");
    … …  
    161152        }
    162153       
    163         async_obsolete_msg_4(multim_dev->console_phone, KBDEV_EVENT, ev.type, ev.key,
    164             ev.mods, ev.c);
     154        async_exch_t *exch = async_exchange_begin(multim_dev->console_sess);
     155        async_msg_4(exch, KBDEV_EVENT, ev.type, ev.key, ev.mods, ev.c);
     156        async_exchange_end(exch);
    165157}
    166158
    … …  
    222214        }
    223215       
    224         multim_dev->console_phone = -1;
     216        multim_dev->console_sess = NULL;
    225217       
    226218        /*! @todo Autorepeat */
    … …  
    250242        if (data != NULL) {
    251243                usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
    252                 // hangup phone to the console
    253                 async_obsolete_hangup(multim_dev->console_phone);
     244                // hangup session to the console
     245                async_hangup(multim_dev->console_sess);
    254246        }
    255247}
Note: See TracChangeset for help on using the changeset viewer.