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

   1 /*
   2     Copyright © 2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: LinuxInput hidd initialization code.
   6     Lang: English.
   7 */
   8
   9 #define DEBUG 0
  10
  11 #define __OOP_NOATTRBASES__
  12
  13 #include <exec/rawfmt.h>
  14 #include <aros/symbolsets.h>
  15 #include <aros/debug.h>
  16 #include <utility/utility.h>
  17 #include <oop/oop.h>
  18 #include <proto/exec.h>
  19 #include <proto/oop.h>
  20 #include <hidd/mouse.h>
  21 #include <hidd/keyboard.h>
  22 #include <hidd/unixio.h>
  23
  24 #include LC_LIBDEFS_FILE
  25
  26 #include "linuxinput_intern.h"
  27
  28 #include <linux/input.h>
  29
  30 #define O_RDONLY    0
  31
  32 /*
  33  * Some attrbases needed as global vars.
  34  * These are write-once read-many.
  35  */
  36 OOP_AttrBase HiddKbdAB;
  37 OOP_AttrBase HiddMouseAB;
  38
  39 static const struct OOP_ABDescr abd[] =
  40 {
  41     { IID_Hidd_Kbd      , &HiddKbdAB    },
  42     { IID_Hidd_Mouse    , &HiddMouseAB  },
  43     { NULL              , NULL          }
  44 };
  45
  46 VOID Update_EventHandlers(struct LinuxInput_staticdata *lsd)
  47 {
  48     struct EventHandler * eh;
  49     ForeachNode(&lsd->eventhandlers, eh)
  50     {
  51         eh->mousehidd   = lsd->mousehidd;
  52         eh->kbdhidd     = lsd->kbdhidd;
  53         eh->unixio      = lsd->unixio;
  54     }
  55 }
  56
  57 static inline void _sprintf(UBYTE *buffer, UBYTE *format, ...)
  58 {
  59     va_list args;
  60
  61     va_start(args, format);
  62     VNewRawDoFmt(format, RAWFMTFUNC_STRING, buffer, args);
  63     va_end(args);
  64 }
  65
  66 static VOID Enumerate_InputDevices(struct LinuxInput_staticdata *lsd)
  67 {
  68     int fd, ioerr, read;
  69     LONG i = 0;
  70     TEXT eventdev[64];
  71
  72
  73     while(TRUE)
  74     {
  75         LONG param = 0;
  76         struct EventHandler * eh = NULL;
  77
  78         _sprintf(eventdev, "/dev/input/event%d", i);
  79
  80         D(bug("[LinuxInput] Testing %s\n", eventdev));
  81
  82         fd = Hidd_UnixIO_OpenFile(lsd->unixio, eventdev, O_RDONLY, 0, &ioerr);
  83         if (fd< 0)
  84             break;
  85
  86         read = Hidd_UnixIO_IOControlFile(lsd->unixio, fd, EVIOCGBIT(0, EV_MAX), &param,&ioerr);
  87
  88         if (read < 0)
  89             continue;
  90
  91         eh = AllocVec(sizeof(struct EventHandler), MEMF_PUBLIC | MEMF_CLEAR);
  92         eh->eventdev = fd;
  93         eh->capabilities = CAP_NONE;
  94
  95         if ((param & (1 << EV_REP)) && (param& (1 << EV_KEY)))
  96         {
  97             /* Mouse */
  98             eh->capabilities |= CAP_KEYBOARD;
  99             D(bug("[LinuxInput] Found Keyboard\n"));
 100         }
 101
 102         if ((param & (1 << EV_REL)) && (param& (1 << EV_KEY)))
 103         {
 104             /* Mouse */
 105             eh->capabilities |= CAP_MOUSE;
 106             D(bug("[LinuxInput] Found Mouse\n"));
 107         }
 108
 109
 110         if (eh->capabilities != CAP_NONE)
 111             ADDHEAD(&lsd->eventhandlers, eh);
 112         else
 113             FreeVec(eh);
 114
 115         i++;
 116     }
 117 }
 118
 119 VOID Init_LinuxInput_inputtask(struct EventHandler * eh);
 120 VOID Kill_LinuxInput_inputtask(struct EventHandler * eh);
 121
 122 static int Init_Hidd(LIBBASETYPEPTR LIBBASE)
 123 {
 124     struct EventHandler * eh;
 125
 126     InitSemaphore(&LIBBASE->lsd.sema);
 127     NEWLIST(&LIBBASE->lsd.eventhandlers);
 128
 129     /*
 130      * We cannot cooperate with any other driver at the moment.
 131      * Attempting to do so results in duplicating events (one from
 132      * X11 and another from us).
 133      */
 134     if (OOP_FindClass("hidd.gfx.x11"))
 135         return FALSE;
 136
 137     D(bug("[LinuxInput] Opening UnixIO... "));
 138     LIBBASE->lsd.unixio = OOP_NewObject(NULL, CLID_Hidd_UnixIO, NULL);
 139     if (!LIBBASE->lsd.unixio)
 140     {
 141         D(bug("Failed\n"));
 142         return FALSE;
 143     }
 144     D(bug("OK\n"));
 145
 146     Enumerate_InputDevices(&LIBBASE->lsd);
 147     if (IsListEmpty(&LIBBASE->lsd.eventhandlers))
 148         return FALSE;
 149
 150     if (!OOP_ObtainAttrBases(abd))
 151         return FALSE;
 152
 153     Update_EventHandlers(&LIBBASE->lsd);
 154
 155     ForeachNode(&LIBBASE->lsd.eventhandlers, eh)
 156     {
 157         Init_LinuxInput_inputtask(eh);
 158     }
 159
 160     D(bug("[LinuxInput] Finished Init_Hidd"));
 161
 162     return TRUE;
 163 }
 164
 165 static int Expunge_Hidd(LIBBASETYPEPTR LIBBASE)
 166 {
 167     int ioerr;
 168     struct EventHandler * eh;
 169
 170     ForeachNode(&LIBBASE->lsd.eventhandlers, eh)
 171     {
 172         Kill_LinuxInput_inputtask(eh);
 173         Hidd_UnixIO_CloseFile(LIBBASE->lsd.unixio, eh->eventdev, &ioerr);
 174     }
 175
 176     OOP_ReleaseAttrBases(abd);
 177
 178     if (LIBBASE->lsd.unixio)
 179         OOP_DisposeObject(LIBBASE->lsd.unixio);
 180
 181     return TRUE;
 182 }
 183
 184 ADD2INITLIB(Init_Hidd, 1)
 185 ADD2EXPUNGELIB(Expunge_Hidd, 1)