Changes in / [503e4e3:b670523] in mainline


Ignore:
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • boot/generic/src/version.c

    r503e4e3 rb670523  
    3232
    3333static const char *project = "HelenOS bootloader";
    34 static const char *copyright = "Copyright (c) 2001-2010 HelenOS project";
     34static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
    3535static const char *release = STRING(RELEASE);
    3636static const char *name = STRING(NAME);

  • kernel/generic/src/main/version.c

    r503e4e3 rb670523  
    3838
    3939static const char *project = "SPARTAN kernel";
    40 static const char *copyright = "Copyright (c) 2001-2010 HelenOS project";
     40static const char *copyright = "Copyright (c) 2001-2011 HelenOS project";
    4141static const char *release = STRING(RELEASE);
    4242static const char *name = STRING(NAME);

  • uspace/app/getterm/version.c

    r503e4e3 rb670523  
    6161        printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
    6262        printf("Running on %s (%s)\n", arch, term);
    63         printf("Copyright (c) 2001-2010 HelenOS project\n\n");
     63        printf("Copyright (c) 2001-2011 HelenOS project\n\n");
    6464}
    6565

  • uspace/drv/usbmouse/init.c

    r503e4e3 rb670523  
    4343#include <errno.h>
    4444
    45 // FIXME: remove this header
    46 #include <kernel/ipc/ipc_methods.h>
    47 
    4845/** Mouse polling endpoint description for boot protocol subclass. */
    4946usb_endpoint_description_t poll_endpoint_description = {
    … …  
    5653};
    5754
    58 static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
     55/** Default handler for IPC methods not handled by DDF.
     56 *
     57 * @param fun     Device function handling the call.
     58 * @param icallid Call ID.
     59 * @param icall   Call data.
     60 *
     61 */
     62static void default_connection_handler(ddf_fun_t *fun, ipc_callid_t icallid,
     63    ipc_call_t *icall)
     64{
     65        usb_mouse_t *mouse = (usb_mouse_t *) fun->driver_data;
     66        assert(mouse != NULL);
     67       
     68        async_sess_t *callback =
     69            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     70       
     71        if (callback) {
     72                if (mouse->console_sess == NULL) {
     73                        mouse->console_sess = callback;
     74                        async_answer_0(icallid, EOK);
     75                } else
     76                        async_answer_0(icallid, ELIMIT);
     77        } else
     78                async_answer_0(icallid, EINVAL);
     79}
     80
    5981/** Device ops for USB mouse. */
    6082static ddf_dev_ops_t mouse_ops = {
    6183        .default_handler = default_connection_handler
    6284};
    63 
    64 /** Default handler for IPC methods not handled by DDF.
    65  *
    66  * @param fun Device function handling the call.
    67  * @param icallid Call id.
    68  * @param icall Call data.
    69  */
    70 void default_connection_handler(ddf_fun_t *fun,
    71     ipc_callid_t icallid, ipc_call_t *icall)
    72 {
    73         sysarg_t method = IPC_GET_IMETHOD(*icall);
    74 
    75         usb_mouse_t *mouse = (usb_mouse_t *) fun->driver_data;
    76         assert(mouse != NULL);
    77 
    78         if (method == IPC_M_CONNECT_TO_ME) {
    79                 int callback = IPC_GET_ARG5(*icall);
    80 
    81                 if (mouse->console_phone != -1) {
    82                         async_answer_0(icallid, ELIMIT);
    83                         return;
    84                 }
    85 
    86                 mouse->console_phone = callback;
    87                 async_answer_0(icallid, EOK);
    88                 return;
    89         }
    90 
    91         async_answer_0(icallid, EINVAL);
    92 }
    9385
    9486/** Create USB mouse device.
    … …  
    10294{
    10395        usb_mouse_t *mouse = malloc(sizeof(usb_mouse_t));
    104         if (mouse == NULL) {
     96        if (mouse == NULL)
    10597                return ENOMEM;
    106         }
     98       
    10799        mouse->dev = dev;
    108         mouse->console_phone = -1;
    109 
     100        mouse->console_sess = NULL;
     101       
    110102        int rc;
    111 
     103       
    112104        /* Create DDF function. */
    113105        mouse->mouse_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, "mouse");
    … …  
    116108                goto leave;
    117109        }
    118 
     110       
    119111        mouse->mouse_fun->ops = &mouse_ops;
    120 
     112       
    121113        rc = ddf_fun_bind(mouse->mouse_fun);
    122         if (rc != EOK) {
     114        if (rc != EOK)
    123115                goto leave;
    124         }
    125 
     116       
    126117        /* Add the function to mouse class. */
    127118        rc = ddf_fun_add_to_class(mouse->mouse_fun, "mouse");
    128         if (rc != EOK) {
     119        if (rc != EOK)
    129120                goto leave;
    130         }
    131121       
    132122        /* Set the boot protocol. */
    133123        rc = usbhid_req_set_protocol(&dev->ctrl_pipe, dev->interface_no,
    134124            USB_HID_PROTOCOL_BOOT);
    135         if (rc != EOK) {
     125        if (rc != EOK)
    136126                goto leave;
    137         }
    138127       
    139         /* Everything all right. */
     128        /* Everything allright. */
    140129        dev->driver_data = mouse;
    141130        mouse->mouse_fun->driver_data = mouse;
    142 
     131       
    143132        return EOK;
    144 
     133       
    145134leave:
    146135        free(mouse);
    147 
    148136        return rc;
    149137}

  • uspace/drv/usbmouse/main.c

    r503e4e3 rb670523  
    3434 * Main routines of USB boot protocol mouse driver.
    3535 */
     36
    3637#include "mouse.h"
    3738#include <usb/debug.h>
    … …  
    4041#include <str_error.h>
    4142
     43#define NAME  "usbmouse"
     44
    4245/** Callback when new mouse device is attached and recognised by DDF.
    4346 *
    4447 * @param dev Representation of a generic DDF device.
     48 *
    4549 * @return Error code.
     50 *
    4651 */
    4752static int usbmouse_add_device(usb_device_t *dev)
    … …  
    5358                return rc;
    5459        }
    55 
     60       
    5661        usb_log_debug("Polling pipe at endpoint %d.\n",
    5762            dev->pipes[0].pipe->endpoint_no);
    58 
    59         rc = usb_device_auto_poll(dev, 0,
    60             usb_mouse_polling_callback, dev->pipes[0].pipe->max_packet_size,
     63       
     64        rc = usb_device_auto_poll(dev, 0, usb_mouse_polling_callback,
     65            dev->pipes[0].pipe->max_packet_size,
    6166            usb_mouse_polling_ended_callback, dev->driver_data);
    62 
     67       
    6368        if (rc != EOK) {
    6469                usb_log_error("Failed to start polling fibril: %s.\n",
    … …  
    6671                return rc;
    6772        }
    68 
     73       
    6974        usb_log_info("controlling new mouse (handle %" PRIun ").\n",
    7075            dev->ddf_dev->handle);
    71 
     76       
    7277        return EOK;
    7378}
    … …  
    9398{
    9499        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
    95 
    96100        return usb_driver_main(&mouse_driver);
    97101}

  • uspace/drv/usbmouse/mouse.c

    r503e4e3 rb670523  
    4040#include <ipc/mouse.h>
    4141#include <async.h>
    42 #include <async_obsolete.h>
    4342#include "mouse.h"
    4443
    4544/** Mouse polling callback.
    4645 *
    47  * @param dev Device that is being polled.
     46 * @param dev    Device that is being polled.
    4847 * @param buffer Data buffer.
    49  * @param buffer_size Buffer size in bytes.
    50  * @param arg Custom argument - points to usb_mouse_t.
     48 * @param size   Buffer size in bytes.
     49 * @param arg    Pointer to usb_mouse_t.
     50 *
    5151 * @return Always true.
     52 *
    5253 */
    53 bool usb_mouse_polling_callback(usb_device_t *dev,
    54     uint8_t *buffer, size_t buffer_size, void *arg)
     54bool usb_mouse_polling_callback(usb_device_t *dev, uint8_t *buffer,
     55    size_t size, void *arg)
    5556{
    5657        usb_mouse_t *mouse = (usb_mouse_t *) arg;
    57 
     58       
    5859        usb_log_debug2("got buffer: %s.\n",
    59             usb_debug_str_buffer(buffer, buffer_size, 0));
    60 
     60            usb_debug_str_buffer(buffer, size, 0));
     61       
    6162        uint8_t butt = buffer[0];
    6263        char str_buttons[4] = {
    … …  
    6667                0
    6768        };
    68 
     69       
    6970        int shift_x = ((int) buffer[1]) - 127;
    7071        int shift_y = ((int) buffer[2]) - 127;
    7172        int wheel = ((int) buffer[3]) - 127;
    72 
    73         if (buffer[1] == 0) {
     73       
     74        if (buffer[1] == 0)
    7475                shift_x = 0;
    75         }
    76         if (buffer[2] == 0) {
     76       
     77        if (buffer[2] == 0)
    7778                shift_y = 0;
    78         }
    79         if (buffer[3] == 0) {
     79       
     80        if (buffer[3] == 0)
    8081                wheel = 0;
    81         }
    82 
    83         if (mouse->console_phone >= 0) {
     82       
     83        if (mouse->console_sess) {
    8484                if ((shift_x != 0) || (shift_y != 0)) {
    85                         /* FIXME: guessed for QEMU */
    86                         async_obsolete_req_2_0(mouse->console_phone,
    87                             MEVENT_MOVE,
    88                             - shift_x / 10,  - shift_y / 10);
     85                        // FIXME: guessed for QEMU
     86                       
     87                        async_exch_t *exch = async_exchange_begin(mouse->console_sess);
     88                        async_req_2_0(exch, MEVENT_MOVE, -shift_x / 10, -shift_y / 10);
     89                        async_exchange_end(exch);
    8990                }
    9091                if (butt) {
    91                         /* FIXME: proper button clicking. */
    92                         async_obsolete_req_2_0(mouse->console_phone,
    93                             MEVENT_BUTTON, 1, 1);
    94                         async_obsolete_req_2_0(mouse->console_phone,
    95                             MEVENT_BUTTON, 1, 0);
     92                        // FIXME: proper button clicking
     93                       
     94                        async_exch_t *exch = async_exchange_begin(mouse->console_sess);
     95                        async_req_2_0(exch, MEVENT_BUTTON, 1, 1);
     96                        async_req_2_0(exch, MEVENT_BUTTON, 1, 0);
     97                        async_exchange_end(exch);
    9698                }
    9799        }
    98 
     100       
    99101        usb_log_debug("buttons=%s  dX=%+3d  dY=%+3d  wheel=%+3d\n",
    100102            str_buttons, shift_x, shift_y, wheel);
    101 
     103       
    102104        /* Guess. */
    103105        async_usleep(1000);
    104 
     106       
    105107        return true;
    106108}
    … …  
    108110/** Callback when polling is terminated.
    109111 *
    110  * @param dev Device where the polling terminated.
     112 * @param dev              Device where the polling terminated.
    111113 * @param recurring_errors Whether the polling was terminated due to
    112  *      recurring errors.
    113  * @param arg Custom argument - points to usb_mouse_t.
     114 *                         recurring errors.
     115 * @param arg              Pointer to usb_mouse_t.
     116 *
    114117 */
    115 void usb_mouse_polling_ended_callback(usb_device_t *dev,
    116     bool recurring_errors, void *arg)
     118void usb_mouse_polling_ended_callback(usb_device_t *dev, bool recurring_errors,
     119    void *arg)
    117120{
    118121        usb_mouse_t *mouse = (usb_mouse_t *) arg;
    119 
    120         async_obsolete_hangup(mouse->console_phone);
    121         mouse->console_phone = -1;
    122 
     122       
     123        async_hangup(mouse->console_sess);
     124        mouse->console_sess = NULL;
     125       
    123126        usb_device_destroy(dev);
    124127}

  • uspace/drv/usbmouse/mouse.h

    r503e4e3 rb670523  
    3434 * Common definitions for USB mouse driver.
    3535 */
     36
    3637#ifndef USBMOUSE_MOUSE_H_
    3738#define USBMOUSE_MOUSE_H_
    … …  
    4041#include <usb/dev/pipes.h>
    4142#include <time.h>
     43#include <async.h>
    4244
    43 #define NAME "usbmouse"
     45#define POLL_PIPE(dev) \
     46        ((dev)->pipes[0].pipe)
    4447
    4548/** Container for USB mouse device. */
    … …  
    4750        /** Generic device container. */
    4851        usb_device_t *dev;
     52       
    4953        /** Function representing the device. */
    5054        ddf_fun_t *mouse_fun;
     55       
    5156        /** Polling interval in microseconds. */
    5257        suseconds_t poll_interval_us;
    53         /** IPC phone to console (consumer). */
    54         int console_phone;
     58       
     59        /** Callback session to console (consumer). */
     60        async_sess_t *console_sess;
    5561} usb_mouse_t;
    56 
    57 #define POLL_PIPE(dev) ((dev)->pipes[0].pipe)
    5862
    5963extern usb_endpoint_description_t poll_endpoint_description;
    6064
    61 int usb_mouse_create(usb_device_t *);
    62 
    63 bool usb_mouse_polling_callback(usb_device_t *, uint8_t *, size_t, void *);
    64 void usb_mouse_polling_ended_callback(usb_device_t *, bool, void *);
     65extern int usb_mouse_create(usb_device_t *);
     66extern bool usb_mouse_polling_callback(usb_device_t *, uint8_t *, size_t,
     67    void *);
     68extern void usb_mouse_polling_ended_callback(usb_device_t *, bool, void *);
    6569
    6670#endif
     71
    6772/**
    6873 * @}

  • uspace/drv/vhc/conndev.c

    r503e4e3 rb670523  
    4545static fibril_local char plugged_device_name[PLUGGED_DEVICE_NAME_MAXLEN + 1] = "<unknown>";
    4646
    47 #if 0
    4847/** Receive device name.
    4948 *
    … …  
    8584        plugged_device_name[len] = 0;
    8685}
    87 #endif
    8886
    8987/** Default handler for IPC methods not handled by DDF.
    … …  
    9391 * @param icall Call data.
    9492 */
    95 void default_connection_handler(ddf_fun_t *fun,
    96     ipc_callid_t icallid, ipc_call_t *icall)
     93void default_connection_handler(ddf_fun_t *fun, ipc_callid_t icallid,
     94    ipc_call_t *icall)
    9795{
    98 // FIXME:
    99 // This code needs to be refactored since the async
    100 // framework does not support automatic callback connections
    101 // yet.
    102 
    103 #if 0
    10496        vhc_data_t *vhc = fun->dev->driver_data;
    105         sysarg_t method = IPC_GET_IMETHOD(*icall);
    106 
    107         if (method == IPC_M_CONNECT_TO_ME) {
    108                 int callback = IPC_GET_ARG5(*icall);
    109                 int rc = vhc_virtdev_plug(vhc, callback,
    110                     &plugged_device_handle);
     97       
     98        async_sess_t *callback =
     99            async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     100       
     101        if (callback) {
     102                int rc = vhc_virtdev_plug(vhc, callback, &plugged_device_handle);
    111103                if (rc != EOK) {
    112104                        async_answer_0(icallid, rc);
    … …  
    114106                        return;
    115107                }
    116 
     108               
    117109                async_answer_0(icallid, EOK);
    118 
     110               
    119111                receive_device_name(callback);
    120 
     112               
    121113                usb_log_info("New virtual device `%s' (id: %" PRIxn ").\n",
    122114                    plugged_device_name, plugged_device_handle);
    123 
    124                 return;
    125         }
    126 #endif
    127 
    128         async_answer_0(icallid, EINVAL);
     115        } else
     116                async_answer_0(icallid, EINVAL);
    129117}
    130118

  • uspace/lib/c/generic/async.c

    r503e4e3 rb670523  
    23392339 * @param mgmt Exchange management style.
    23402340 *
    2341  * @return New async session or NULL on failure.
     2341 * @return New async session.
     2342 * @return NULL on failure.
    23422343 *
    23432344 */
    … …  
    23772378}
    23782379
     2380/** Wrapper for receiving the IPC_M_CONNECT_TO_ME calls.
     2381 *
     2382 * If the call is IPC_M_CONNECT_TO_ME then a new
     2383 * async session is created. However, the phone is
     2384 * not accepted automatically.
     2385 *
     2386 * @param mgmt   Exchange management style.
     2387 * @param call   Call data.
     2388 *
     2389 * @return New async session.
     2390 * @return NULL on failure.
     2391 * @return NULL if the call is not IPC_M_CONNECT_TO_ME.
     2392 *
     2393 */
     2394async_sess_t *async_callback_receive_start(exch_mgmt_t mgmt, ipc_call_t *call)
     2395{
     2396        int phone = (int) IPC_GET_ARG5(*call);
     2397       
     2398        if ((IPC_GET_IMETHOD(*call) != IPC_M_CONNECT_TO_ME) ||
     2399            (phone < 0))
     2400                return NULL;
     2401       
     2402        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
     2403        if (sess == NULL)
     2404                return NULL;
     2405       
     2406        sess->mgmt = mgmt;
     2407        sess->phone = phone;
     2408        sess->arg1 = 0;
     2409        sess->arg2 = 0;
     2410        sess->arg3 = 0;
     2411       
     2412        list_initialize(&sess->exch_list);
     2413        fibril_mutex_initialize(&sess->mutex);
     2414        atomic_set(&sess->refcnt, 0);
     2415       
     2416        return sess;
     2417}
     2418
    23792419/** @}
    23802420 */

  • uspace/lib/c/generic/devman.c

    r503e4e3 rb670523  
    231231        }
    232232       
    233         async_wait_for(req, &retval);
    234         if (retval != EOK) {
    235                 devman_exchange_end(exch);
    236                
    237                 if (funh != NULL)
    238                         *funh = -1;
    239                
    240                 return retval;
    241         }
    242        
    243         if (funh != NULL)
    244                 *funh = (int) IPC_GET_ARG1(answer);
    245        
    246233        link_t *link = match_ids->ids.next;
    247234        match_id_t *match_id = NULL;
    … …  
    250237                match_id = list_get_instance(link, match_id_t, link);
    251238               
    252                 ipc_call_t answer;
    253                 aid_t req = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
    254                     match_id->score, &answer);
     239                ipc_call_t answer2;
     240                aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
     241                    match_id->score, &answer2);
    255242                retval = async_data_write_start(exch, match_id->id,
    256243                    str_size(match_id->id));
     244                if (retval != EOK) {
     245                        devman_exchange_end(exch);
     246                        async_wait_for(req2, NULL);
     247                        async_wait_for(req, NULL);
     248                        return retval;
     249                }
     250               
     251                async_wait_for(req2, &retval);
    257252                if (retval != EOK) {
    258253                        devman_exchange_end(exch);
    … …  
    261256                }
    262257               
    263                 async_wait_for(req, &retval);
    264                 if (retval != EOK) {
    265                         devman_exchange_end(exch);
    266                         return retval;
    267                 }
    268                
    269258                link = link->next;
    270259        }
    271260       
    272261        devman_exchange_end(exch);
    273         return EOK;
     262       
     263        async_wait_for(req, &retval);
     264        if (retval == EOK) {
     265                if (funh != NULL)
     266                        *funh = (int) IPC_GET_ARG1(answer);
     267        } else {
     268                if (funh != NULL)
     269                        *funh = -1;
     270        }
     271       
     272        return retval;
    274273}
    275274

  • uspace/lib/c/include/async.h

    r503e4e3 rb670523  
    464464extern async_sess_t *async_clone_receive(exch_mgmt_t);
    465465extern async_sess_t *async_callback_receive(exch_mgmt_t);
     466extern async_sess_t *async_callback_receive_start(exch_mgmt_t, ipc_call_t *);
    466467
    467468#endif
Note: See TracChangeset for help on using the changeset viewer.