arch/all-linux/hidd/linuxinput/linuxinput_inputtask.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Task used for wainting on events from linux
   6     Lang: English.
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <proto/oop.h>
  11 #include <proto/arossupport.h>
  12
  13 #include <exec/memory.h>
  14 #include <exec/tasks.h>
  15 #include <exec/lists.h>
  16
  17 #include <oop/oop.h>
  18 #include <hidd/mouse.h>
  19 #include <hidd/unixio.h>
  20
  21 #define DEBUG 0
  22 #include <aros/debug.h>
  23
  24 #include "linuxinput_intern.h"
  25
  26 #include <linux/input.h>
  27
  28 #define INPUTTASK_PRIORITY      50
  29
  30 #define INPUTTASK_STACKSIZE     (AROS_STACKSIZE)
  31 #define INPUTTASK_NAME          "LinuxInput event task"
  32
  33 struct inputtask_params
  34 {
  35     struct Task *creator;
  36     ULONG ok_signal;
  37     ULONG nok_signal;
  38     struct EventHandler * eh;
  39 };
  40
  41 #define BUFF_SIZE   (64 * sizeof(struct input_event))
  42
  43 #define vHidd_Mouse_NoMotion (23839)
  44
  45 static VOID HIDD_LinuxInput_HandleMouseEvent(struct EventHandler * eh, struct pHidd_Mouse_Event *mouse_event)
  46 {
  47     if ((eh->capabilities & CAP_MOUSE) && eh->mousehidd)
  48         HIDD_LinuxMouse_HandleEvent((OOP_Object *)eh->mousehidd, mouse_event);
  49 }
  50
  51 static VOID HIDD_LinuxInput_HandleKbdEvent(struct EventHandler * eh, UBYTE scanCode)
  52 {
  53     if ((eh->capabilities & CAP_KEYBOARD) && eh->kbdhidd)
  54         HIDD_LinuxKbd_HandleEvent((OOP_Object *)eh->kbdhidd, scanCode);
  55 }
  56
  57 static VOID process_input_event(struct input_event * event, struct EventHandler * eh)
  58 {
  59
  60     if (event->type == EV_REL)
  61     {
  62         struct pHidd_Mouse_Event mouse_event;
  63         mouse_event.button = vHidd_Mouse_NoButton;
  64         mouse_event.type = vHidd_Mouse_NoMotion;
  65
  66         if (event->code == REL_X)
  67         {
  68             mouse_event.type = vHidd_Mouse_Motion;
  69             mouse_event.x = event->value;
  70             mouse_event.y = 0;
  71         }
  72
  73         if (event->code == REL_Y)
  74         {
  75             mouse_event.type = vHidd_Mouse_Motion;
  76             mouse_event.x = 0;
  77             mouse_event.y = event->value;
  78         }
  79
  80         if (event->code == REL_WHEEL)
  81         {
  82             mouse_event.type = vHidd_Mouse_WheelMotion;
  83             mouse_event.x = 0;
  84             mouse_event.y = -event->value;
  85         }
  86
  87         if (mouse_event.type != vHidd_Mouse_NoMotion)
  88             HIDD_LinuxInput_HandleMouseEvent(eh, &mouse_event);
  89     }
  90
  91     if (event->type == EV_KEY )
  92     {
  93         struct pHidd_Mouse_Event mouse_event;
  94         mouse_event.button = vHidd_Mouse_NoButton;
  95         switch(event->code)
  96         {
  97         case(BTN_LEFT): mouse_event.button = vHidd_Mouse_Button1; break;
  98         case(BTN_RIGHT): mouse_event.button = vHidd_Mouse_Button2; break;
  99         case(BTN_MIDDLE): mouse_event.button = vHidd_Mouse_Button3; break;
 100         }
 101
 102         if (mouse_event.button != vHidd_Mouse_NoButton)
 103         {
 104             mouse_event.type = event->value == 1 ? vHidd_Mouse_Press : vHidd_Mouse_Release;
 105             HIDD_LinuxInput_HandleMouseEvent(eh, &mouse_event);
 106         }
 107
 108         if ((event->code >= KEY_RESERVED) && (event->code <= KEY_COMPOSE))
 109         {
 110             UBYTE scanCode = (UBYTE)event->code;
 111             if (event->value == 0) scanCode |= 0x80;
 112             HIDD_LinuxInput_HandleKbdEvent(eh, scanCode);
 113         }
 114     }
 115 }
 116
 117 static VOID inputtask_entry()
 118 {
 119     struct EventHandler * eh;
 120     struct inputtask_params itp;
 121     BYTE * buff = NULL;
 122     int ioerr;
 123     LONG bytesread = 0, items = 0, i;
 124     BYTE * ptr = NULL;
 125
 126     /* We must copy the parameter struct because they are allocated
 127      on the parent's stack */
 128
 129     D(bug("INSIDE INPUT TASK\n"));
 130     itp = *((struct inputtask_params *)FindTask(NULL)->tc_UserData);
 131     eh = itp.eh;
 132     D(bug("in inputtask: lsd = %p\n", lsd));
 133     D(bug("FDS: %d\n", lsd->mousedev));
 134
 135     buff = AllocMem(BUFF_SIZE, MEMF_PUBLIC);
 136     if (!buff)
 137         goto failexit;
 138
 139     Signal(itp.creator, itp.ok_signal);
 140
 141     for (;;)
 142     {
 143         /* TODO: wait for SIGBREAKF_CTRL_C and then signal "caller" task */
 144
 145         Hidd_UnixIO_Wait(eh->unixio, eh->eventdev, vHidd_UnixIO_Read);
 146         bytesread = Hidd_UnixIO_ReadFile(eh->unixio, eh->eventdev, buff, BUFF_SIZE, &ioerr);
 147         items = bytesread / sizeof(struct input_event);
 148
 149         ptr = buff;
 150
 151         for (i = 0; i < items; i++)
 152         {
 153             process_input_event((struct input_event *)ptr, eh);
 154             ptr += sizeof(struct input_event);
 155         }
 156     }
 157
 158     FreeMem(buff, BUFF_SIZE);
 159
 160     return;
 161
 162 failexit:
 163
 164     if (buff)
 165         FreeMem(buff, BUFF_SIZE);
 166
 167     Signal(itp.creator, itp.nok_signal);
 168
 169     return;
 170
 171 }
 172
 173 static struct Task *create_inputtask( struct inputtask_params *params)
 174 {
 175     struct Task *task;
 176     APTR stack;
 177
 178     task = AllocMem(sizeof (struct Task), MEMF_PUBLIC|MEMF_CLEAR);
 179     if (NULL != task)
 180     {
 181         NEWLIST(&task->tc_MemEntry);
 182         task->tc_Node.ln_Type=NT_TASK;
 183         task->tc_Node.ln_Name= INPUTTASK_NAME;
 184         task->tc_Node.ln_Pri = INPUTTASK_PRIORITY;
 185
 186         stack=AllocMem(INPUTTASK_STACKSIZE, MEMF_PUBLIC);
 187         if(NULL != stack)
 188         {
 189             task->tc_SPLower=stack;
 190             task->tc_SPUpper=(BYTE *)stack + INPUTTASK_STACKSIZE;
 191             task->tc_UserData=params;
 192
 193 #if AROS_STACK_GROWS_DOWNWARDS
 194             task->tc_SPReg=(BYTE *)task->tc_SPUpper-SP_OFFSET-sizeof(APTR);
 195 #else
 196             task->tc_SPReg=(BYTE *)task->tc_SPLower-SP_OFFSET+sizeof(APTR);
 197 #endif
 198             /* You have to clear signals first. */
 199             SetSignal(0, params->ok_signal | params->nok_signal);
 200
 201             if(AddTask(task, inputtask_entry, NULL) != NULL)
 202             {
 203                 /* Everything went OK. Wait for task to initialize */
 204                 ULONG sigset;
 205
 206                 D(bug("WAITING FOR SIGNAL\n"));
 207
 208                 sigset = Wait( params->ok_signal | params->nok_signal );
 209                 D(bug("GOT SIGNAL\n"));
 210                 if (sigset & params->ok_signal)
 211                     return task;
 212             }
 213
 214             FreeMem(stack, INPUTTASK_STACKSIZE);
 215         }
 216
 217         FreeMem(task,sizeof(struct Task));
 218     }
 219
 220     return NULL;
 221 }
 222
 223 VOID Init_LinuxInput_inputtask(struct EventHandler * eh)
 224 {
 225     struct inputtask_params p;
 226     p.ok_signal = AllocSignal(-1L);
 227     p.nok_signal = AllocSignal(-1L);
 228     p.eh = eh;
 229     p.creator = FindTask(NULL);
 230
 231     D(bug("init_input_task: p.lsd = %p, p.creator = %p\n", p.lsd, p.creator));
 232
 233     D(bug("SIGNALS ALLOCATED\n"));
 234
 235     eh->inputtask = create_inputtask(&p);
 236
 237     D(bug("INPUTTASK CREATED\n"));
 238
 239     /* No need for these anymore */
 240     FreeSignal(p.ok_signal);
 241     FreeSignal(p.nok_signal);
 242 }
 243
 244 VOID Kill_LinuxInput_inputtask(struct EventHandler * eh)
 245 {
 246     /* TODO: Create signal in this task and pass it somehow to input_task */
 247     Signal(eh->inputtask, SIGBREAKF_CTRL_C);
 248     /* TODO: wait input task to mark previously crated signal */
 249 }