Changeset ec153a0 in mainline


Ignore:
Timestamp:
2006-05-16T09:46:22Z (19 years ago)
Author:
Josef Cejka <malyzelenyhnus@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ca603c6
Parents:
250717cc
Message:

Comments update.
Fix problem with multiple buffered callers awaiting key.

Location:
kbd
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • kbd/generic/kbd.c

    r250717cc rec153a0  
    5353       
    5454        ipcarg_t retval, arg1, arg2;
    55        
     55
     56        /* Counter of unsatisfied calls */
    5657        fifo_count_t callers_counter = 0;
    57        
     58        /* Fifo with callid's of unsatisfied calls requred for answer */
    5859        FIFO_INITIALIZE_STATIC(callers_buffer, ipc_callid_t, KBD_REQUEST_MAX);
    5960
    … …  
    8182        //      printf("%s:Call phone=%lX..", NAME, call.in_phone_hash);
    8283                switch (IPC_GET_METHOD(call)) {
    83                 case IPC_M_PHONE_HUNGUP:
    84                         if (connected) {
    85                                 if (--connected == 0) {
    86                                         callers_counter = 0;
    87                                         callers_buffer.head = callers_buffer.tail = 0;
    88                                         key_buffer_free();     
     84                        case IPC_M_PHONE_HUNGUP:
     85                                if (connected) {
     86                                        /* If nobody's connected, clear keybuffer and dont store new keys */
     87                                        if (--connected == 0) {
     88                                                callers_counter = 0;
     89                                                callers_buffer.head = callers_buffer.tail = 0;
     90                                                key_buffer_free();     
     91                                        }
     92                                       
     93                                        printf("%s: Phone hung up.\n", NAME);
     94                                } else {
     95                                        printf("%s: Oops, got phone hung up, but nobody connected.\n", NAME);
    8996                                }
    90                         }
    91                        
    92                         printf("%s: Phone hung up.\n", NAME);
    93                         retval = 0;
    94                         break;
    95                 case IPC_M_CONNECT_TO_ME:
    96                         printf("%s: Somebody connecting phid=%zd.\n", NAME, IPC_GET_ARG3(call));
    97                         retval = 0;
    98                         break;
    99                 case IPC_M_CONNECT_ME_TO:
    100                 //      printf("%s: Connect me (%P) to: %zd\n",NAME, IPC_GET_ARG3(call), IPC_GET_ARG1(call));
    101                         if (connected) {
    102                                 retval = ELIMIT;
    103                         } else {
     97                               
    10498                                retval = 0;
    105                                 connected = 1;
    106                         }
    107                         break;
    108                 case IPC_M_INTERRUPT:
    109                         if (connected) {
    110                                 kbd_arch_process(IPC_GET_ARG2(call));
    111                         }
    112                         //printf("%s: GOT INTERRUPT: %c\n", NAME, IPC_GET_ARG2(call));
    113                         if (!callers_counter)
    11499                                break;
    115                         /* Small trick - interrupt does not need answer so we can change callid to caller awaiting key */
    116                         callers_counter--;
    117                         callid = fifo_pop(callers_buffer);
    118                 case KBD_GETCHAR:
    119 //                      printf("%s: Getchar: ", NAME);
    120                         retval = 0;
    121                         arg1 = 0;       
    122                         if (!key_buffer_pop((char *)&arg1)) {
    123                                 if (callers_counter < KBD_REQUEST_MAX) {
    124                                         callers_counter++;
    125                                         fifo_push(callers_buffer, callid);
     100                        case IPC_M_CONNECT_TO_ME:
     101                                printf("%s: Somebody connecting phid=%zd.\n", NAME, IPC_GET_ARG3(call));
     102                                retval = 0;
     103                                break;
     104                        case IPC_M_CONNECT_ME_TO:
     105                        //      printf("%s: Connect me (%P) to: %zd\n",NAME, IPC_GET_ARG3(call), IPC_GET_ARG1(call));
     106                                /* Only one connected client allowed */
     107                                if (connected) {
     108                                        retval = ELIMIT;
    126109                                } else {
    127                                         retval = ELIMIT;
     110                                        retval = 0;
     111                                        connected = 1;
    128112                                }
    129                                 continue;
    130                         };
    131                         arg2 = 0xbeef;
    132                 //      printf("GetChar return %c\n", arg1);
    133                        
    134                         break;
    135                 default:
    136                         printf("%s: Unknown method: %zd\n", NAME, IPC_GET_METHOD(call));
    137                         retval = ENOENT;
    138                         break;
     113                                break;
     114                        case IPC_M_INTERRUPT:
     115                                if (connected) {
     116                                        /* recode scancode and store it into key buffer */
     117                                        kbd_arch_process(IPC_GET_ARG2(call));
     118                                        //printf("%s: GOT INTERRUPT: %c\n", NAME, IPC_GET_ARG2(call));
     119
     120                                        /* Some callers could awaiting keypress - if its true, we have to send keys to them.
     121                                         * One interrupt can store more than one key into buffer. */
     122                                        retval = 0;
     123                                        arg2 = 0xbeef;
     124                                        while ((callers_counter) && (!key_buffer_empty())) {
     125                                                callers_counter--;
     126                                                if (!key_buffer_pop((char *)&arg1)) {
     127                                                        printf("%s: KeyBuffer empty but it should not be.\n");
     128                                                        break;
     129                                                }
     130                                                ipc_answer_fast(fifo_pop(callers_buffer), retval, arg1, arg2);
     131                                        }
     132                                }
     133                                break;
     134                        case KBD_GETCHAR:
     135        //                      printf("%s: Getchar: ", NAME);
     136                                retval = 0;
     137                                arg1 = 0;       
     138                                if (!key_buffer_pop((char *)&arg1)) {
     139                                        if (callers_counter < KBD_REQUEST_MAX) {
     140                                                callers_counter++;
     141                                                fifo_push(callers_buffer, callid);
     142                                        } else {
     143                                                retval = ELIMIT;
     144                                        }
     145                                        continue;
     146                                };
     147                                arg2 = 0xbeef;
     148                        //      printf("GetChar return %c\n", arg1);
     149                               
     150                                break;
     151                        default:
     152                                printf("%s: Unknown method: %zd\n", NAME, IPC_GET_METHOD(call));
     153                                retval = ENOENT;
     154                                break;
    139155                }
     156
    140157                if (! (callid & IPC_CALLID_NOTIFICATION)) {
    141                 //      printf("%s: Answering\n", NAME);
    142158                        ipc_answer_fast(callid, retval, arg1, arg2);
    143159                }
    144160        }
    145161}
     162

  • kbd/generic/key_buffer.c

    r250717cc rec153a0  
    3030#include <fifo.h>
    3131
    32 #define KBD_BUFFER_SIZE 128
     32#define KBD_BUFFER_SIZE 128 /**< Size of buffer for pressed keys */
    3333
    34 FIFO_INITIALIZE_STATIC(buffer, char, KBD_BUFFER_SIZE);
    35 fifo_count_t buffer_items;
     34FIFO_INITIALIZE_STATIC(buffer, char, KBD_BUFFER_SIZE);  /**< Fifo for storing pressed keys */
     35fifo_count_t buffer_items;      /**< Counter of used items for prevent fifo overflow */
    3636
     37/** Clear key buffer.
     38 */
    3739void key_buffer_free(void)
    3840{
    … …  
    4143}
    4244
     45/** Key buffer initialization.
     46 *
     47 */
    4348void key_buffer_init(void)
    4449{
    … …  
    4651}
    4752
    48 /**
     53/** Get free space in buffer.
     54 * This function is useful for processing some scancodes that are translated
     55 * to more than one character.
    4956 * @return empty buffer space
    5057 */
    … …  
    5461}
    5562
     63/**
     64 * @return nonzero, if buffer is not empty.
     65 */
     66int key_buffer_empty(void)
     67{
     68        return (buffer_items == 0);
     69}
     70
     71/** Push key to key buffer.
     72 * If buffer is full, character is ignored.
     73 * @param key code of stored key
     74 */
    5675void key_buffer_push(char key)
    5776{
    58         /* TODO: somebody may wait for key */
    5977        if (buffer_items < KBD_BUFFER_SIZE) {
    6078                fifo_push(buffer, key);
    … …  
    6482
    6583/** Pop character from buffer.
    66  * @param c
     84 * @param c pointer to space where to store character from buffer.
    6785 * @return zero on empty buffer, nonzero else
    6886 */

  • kbd/include/key_buffer.h

    r250717cc rec153a0  
    3535void key_buffer_init(void);
    3636int key_buffer_available(void);
     37int key_buffer_empty(void);
    3738void key_buffer_push(char key);
    3839int key_buffer_pop(char *c);
Note: See TracChangeset for help on using the changeset viewer.