kernel/drivers/char/mouse/ps2.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2009  Martin 'povik' Poviser (martin.povik@gmail.com)
   4  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *
   6  *  This program is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <build.h>
  21
  22 #ifdef ARCH_i386
  23
  24 #include <system.h>
  25 #include <arch/io.h>
  26 #include <mouse.h>
  27 #include <task.h>
  28
  29 #define KBD_CCMD_KBD_DISABLE            0xAD
  30
  31 #define PS2MOUSE_TIMEOUT                500000
  32 #define PS2MOUSE_ACK                    0xFA
  33 #define PS2MOUSE_PORT                   0x60
  34 #define PS2MOUSE_CTRL                   0x64
  35 #define PS2MOUSE_COMMAND                0xD4
  36 #define PS2MOUSE_COMMAND_RESET          0xFF
  37 #define PS2MOUSE_COMMAND_GET_MOUSE_ID   0xF2
  38 #define PS2MOUSE_COMMAND_GET_PACKET     0xEB
  39 #define PS2MOUSE_COMMAND_ENABLE_PACKETS 0xF4
  40 #define PS2MOUSE_COMMAND_SET_SAMPLERATE 0xF3
  41 #define PS2MOUSE_COMMAND_SET_RESOLUTION 0xE8
  42 #define PS2MOUSE_COMMAND_SET_REMOTE     0xF0
  43 #define PS2MOUSE_RESET_ACK              0xAA
  44 #define PS2MOUSE_IRQ                    12
  45
  46 #define PS2MOUSE_SAMPLERATE_80          0x50
  47 #define PS2MOUSE_SAMPLERATE_100         0x64
  48 #define PS2MOUSE_SAMPLERATE_200         0xC8
  49
  50 #define PS2MOUSE_SAMPLERATE             PS2MOUSE_SAMPLERATE_100
  51
  52
  53 static unsigned ps2mouse_extwheel = 0;
  54 static unsigned ps2mouse_extbuttons = 0;
  55
  56 static dev_mouse_t ps2mouse_state;
  57
  58 static unsigned ps2mouse_reset ();
  59 static unsigned ps2mouse_write (unsigned char command);
  60 static unsigned char ps2mouse_read ();
  61
  62 /* ps2mouse_reset - reset mouse */
  63
  64 unsigned ps2mouse_reset ()
  65 {
  66         int timeout;
  67
  68         for (timeout = 0; timeout < PS2MOUSE_TIMEOUT; timeout ++) {
  69                 if((inb (PS2MOUSE_CTRL) && 0x02) != 0x02)
  70                         break;
  71         }
  72
  73         outb (PS2MOUSE_CTRL, PS2MOUSE_COMMAND);
  74         outb (PS2MOUSE_PORT, PS2MOUSE_COMMAND_RESET);
  75
  76         int ack = 0;
  77
  78         for (timeout = 0; timeout < PS2MOUSE_TIMEOUT; timeout ++) {
  79                 unsigned char state = ps2mouse_read ();
  80
  81                 if (state == PS2MOUSE_ACK)
  82                         ack = 1;
  83
  84                 if (ack && state == PS2MOUSE_RESET_ACK)
  85                         return 1;
  86
  87                 if (state == -1)
  88                         return 0;
  89         }
  90
  91         return -1;
  92 }
  93
  94 /* ps2mouse_write - send a command to mouse */
  95
  96 unsigned ps2mouse_write (unsigned char command)
  97 {
  98         int timeout;
  99
 100         for (timeout = 0; timeout < PS2MOUSE_TIMEOUT; timeout ++) {
 101                 if((inb (PS2MOUSE_CTRL) && 0x02) != 0x02)
 102                         break;
 103         }
 104
 105         outb (PS2MOUSE_CTRL, PS2MOUSE_COMMAND);
 106         outb (PS2MOUSE_PORT, command);
 107
 108         short read = ps2mouse_read ();
 109
 110         if (read == PS2MOUSE_ACK)
 111                 return 1;
 112
 113         if (read == -1)
 114                 return 0;
 115
 116         return 0;
 117 }
 118
 119 /* ps2mouse_read - read a value from mouse */
 120
 121 unsigned char ps2mouse_read ()
 122 {
 123         int timeout;
 124
 125         for (timeout = 0; timeout < PS2MOUSE_TIMEOUT; timeout ++) {
 126                 if ((inb (PS2MOUSE_CTRL) && 0x01) == 0x01)
 127                         return inb (PS2MOUSE_PORT);
 128         }
 129
 130         return -1;
 131 }
 132
 133 /* ps2mouse_get_state - get a mouse state */
 134
 135 unsigned ps2mouse_get_state ()
 136 {
 137         unsigned char b1, b2, b3, b4 = 0;
 138
 139         if (ps2mouse_write (PS2MOUSE_COMMAND_GET_PACKET) == -1)
 140                 return 0;
 141
 142         b1 = ps2mouse_read ();
 143         b2 = ps2mouse_read ();
 144         b3 = ps2mouse_read ();
 145
 146         if (ps2mouse_extwheel || ps2mouse_extbuttons)
 147                 b4 = ps2mouse_read ();
 148
 149         ps2mouse_state.flags = 0;
 150         ps2mouse_state.flags |= ((b1 & 1) ? MOUSE_FLAG_BUTTON1 : 0);
 151         ps2mouse_state.flags |= ((b1 & 2) ? MOUSE_FLAG_BUTTON2 : 0);
 152         ps2mouse_state.flags |= ((b1 & 3) ? MOUSE_FLAG_BUTTON3 : 0);
 153         ps2mouse_state.flags |= ((b1 & 4) ? MOUSE_FLAG_BUTTON4 : 0);
 154         ps2mouse_state.flags |= ((b1 & 5) ? MOUSE_FLAG_BUTTON5 : 0);
 155
 156         short dx, dy, dz;
 157
 158         dx = (b1 & 0x10) ? b2 - 256 : b2;
 159         dy = (b1 & 0x20) ? -(b3 - 256) : -b3;
 160         dz = (b4 & 0x08) ? (b4 & 7) - 8 : b4 & 7;
 161
 162         if (dx > 5 || dx < -5)
 163                 dx *= 4;
 164         if (dy > 5 || dy < -5)
 165                 dy *= 4;
 166
 167         ps2mouse_state.pos_x = dx;
 168         ps2mouse_state.pos_y = dy;
 169
 170         if (dz > 0)
 171                 ps2mouse_state.flags = ps2mouse_state.flags | MOUSE_FLAG_SCROLLUP;
 172         if (dz < 0)
 173                 ps2mouse_state.flags = ps2mouse_state.flags | MOUSE_FLAG_SCROLLDOWN;
 174
 175         return 1;
 176 }
 177
 178 unsigned char ps2mouse_get_mouseid ()
 179 {
 180         short mouse_id;
 181
 182         ps2mouse_write (PS2MOUSE_COMMAND_SET_SAMPLERATE);
 183         ps2mouse_write (PS2MOUSE_SAMPLERATE_200);
 184
 185         ps2mouse_write (PS2MOUSE_COMMAND_SET_SAMPLERATE);
 186         ps2mouse_write (PS2MOUSE_SAMPLERATE_100);
 187
 188         ps2mouse_write (PS2MOUSE_COMMAND_SET_SAMPLERATE);
 189         ps2mouse_write (PS2MOUSE_SAMPLERATE_80);
 190
 191         ps2mouse_write (PS2MOUSE_COMMAND_GET_MOUSE_ID);
 192         mouse_id = ps2mouse_read ();
 193
 194         if (mouse_id < 3)
 195                 goto ret;
 196         else
 197                 ps2mouse_extwheel = true;
 198
 199         ps2mouse_write (PS2MOUSE_COMMAND_SET_SAMPLERATE);
 200         ps2mouse_write (PS2MOUSE_SAMPLERATE_200);
 201
 202         ps2mouse_write (PS2MOUSE_COMMAND_SET_SAMPLERATE);
 203         ps2mouse_write (PS2MOUSE_SAMPLERATE_200);
 204
 205         ps2mouse_write (PS2MOUSE_COMMAND_SET_SAMPLERATE);
 206         ps2mouse_write (PS2MOUSE_SAMPLERATE_80);
 207
 208         ps2mouse_write (PS2MOUSE_COMMAND_GET_MOUSE_ID);
 209         mouse_id = ps2mouse_read ();
 210
 211         if (mouse_id > 3)
 212                 ps2mouse_extbuttons = true;
 213 ret:
 214         return mouse_id;
 215 }
 216
 217 unsigned ps2mouse_init ()
 218 {
 219         int timeout;
 220
 221         ps2mouse_extbuttons = false;
 222         ps2mouse_extwheel = false;
 223
 224         if (ps2mouse_reset () != 1)
 225                 return 0;
 226
 227         unsigned char type = ps2mouse_read ();
 228
 229         if (type != 0) {        /* mouse type: 0 = PS2, 3 = IMPS/2, 4 = IMEX */
 230                 kprintf ("> ps2mouse : failed while detecting mouse type (%d), should be (0)\n", type);
 231                 return 0;
 232         }
 233
 234         if (ps2mouse_get_mouseid () == -1)
 235                 return 0;
 236
 237         ps2mouse_write (PS2MOUSE_COMMAND_SET_REMOTE);
 238         ps2mouse_write (PS2MOUSE_COMMAND_ENABLE_PACKETS);
 239
 240         return 1;
 241 }
 242
 243 void ps2mouse_update ()
 244 {
 245         for (;; schedule ()) {
 246                 if (!ps2mouse_state.pos_x && !ps2mouse_state.pos_y)
 247                         ps2mouse_get_state ();
 248         }
 249 }
 250
 251 bool ps2mouse_acthandler (unsigned act, char *block, unsigned block_len)
 252 {
 253         switch (act) {
 254                 case DEV_ACT_INIT:
 255                 {
 256                         dev_flags_t *flags = (dev_flags_t *) block;
 257
 258                         if (!flags)
 259                                 return 0;
 260
 261                         if (block_len != sizeof (dev_flags_t))
 262                                 return 0;
 263
 264                         unsigned r = ps2mouse_init ();
 265
 266                         if (!r)
 267                                 return 0;
 268
 269                         flags->iomem = (void *) &ps2mouse_state;
 270                         flags->iolen = sizeof (dev_mouse_t);
 271
 272                         //task_t *task = task_create ("mouseps2", (unsigned) &ps2mouse_update, 255);
 273
 274                         return r;
 275                 }
 276                 break;
 277                 case DEV_ACT_READ:
 278                 {
 279                         memcpy (block, &ps2mouse_state, sizeof (dev_mouse_t));
 280
 281                         return 1;
 282                 }
 283                 break;
 284                 case DEV_ACT_WRITE:
 285                 {
 286                         memcpy (&ps2mouse_state, block, sizeof (dev_mouse_t));
 287
 288                         return 1;
 289                 }
 290                 break;
 291                 case DEV_ACT_UPDATE:
 292                 {
 293                         ps2mouse_get_state ();
 294
 295                         return 1;
 296                 }
 297                 break;
 298         }
 299
 300         return 0;
 301 }
 302
 303 #endif